// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
package feedsv1beta1

import (
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	runtime "github.com/cosmos/cosmos-proto/runtime"
	_ "github.com/cosmos/gogoproto/gogoproto"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoiface "google.golang.org/protobuf/runtime/protoiface"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	io "io"
	reflect "reflect"
	sync "sync"
)

var (
	md_Signal       protoreflect.MessageDescriptor
	fd_Signal_id    protoreflect.FieldDescriptor
	fd_Signal_power protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_Signal = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("Signal")
	fd_Signal_id = md_Signal.Fields().ByName("id")
	fd_Signal_power = md_Signal.Fields().ByName("power")
}

var _ protoreflect.Message = (*fastReflection_Signal)(nil)

type fastReflection_Signal Signal

func (x *Signal) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Signal)(x)
}

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

var _fastReflection_Signal_messageType fastReflection_Signal_messageType
var _ protoreflect.MessageType = fastReflection_Signal_messageType{}

type fastReflection_Signal_messageType struct{}

func (x fastReflection_Signal_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Signal)(nil)
}
func (x fastReflection_Signal_messageType) New() protoreflect.Message {
	return new(fastReflection_Signal)
}
func (x fastReflection_Signal_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Signal
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Signal) Descriptor() protoreflect.MessageDescriptor {
	return md_Signal
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Signal) Type() protoreflect.MessageType {
	return _fastReflection_Signal_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Signal) New() protoreflect.Message {
	return new(fastReflection_Signal)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Signal) Interface() protoreflect.ProtoMessage {
	return (*Signal)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Signal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != "" {
		value := protoreflect.ValueOfString(x.Id)
		if !f(fd_Signal_id, value) {
			return
		}
	}
	if x.Power != int64(0) {
		value := protoreflect.ValueOfInt64(x.Power)
		if !f(fd_Signal_power, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Signal) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Signal.id":
		return x.Id != ""
	case "band.feeds.v1beta1.Signal.power":
		return x.Power != int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Signal"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Signal does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Signal) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Signal.id":
		x.Id = ""
	case "band.feeds.v1beta1.Signal.power":
		x.Power = int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Signal"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Signal does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Signal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.Signal.id":
		value := x.Id
		return protoreflect.ValueOfString(value)
	case "band.feeds.v1beta1.Signal.power":
		value := x.Power
		return protoreflect.ValueOfInt64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Signal"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Signal does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Signal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Signal.id":
		x.Id = value.Interface().(string)
	case "band.feeds.v1beta1.Signal.power":
		x.Power = value.Int()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Signal"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Signal does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Signal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Signal.id":
		panic(fmt.Errorf("field id of message band.feeds.v1beta1.Signal is not mutable"))
	case "band.feeds.v1beta1.Signal.power":
		panic(fmt.Errorf("field power of message band.feeds.v1beta1.Signal is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Signal"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Signal does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Signal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Signal.id":
		return protoreflect.ValueOfString("")
	case "band.feeds.v1beta1.Signal.power":
		return protoreflect.ValueOfInt64(int64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Signal"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Signal does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Signal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.Signal", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Signal) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Signal) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Signal) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Signal) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Signal)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Id)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Power != 0 {
			n += 1 + runtime.Sov(uint64(x.Power))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Signal)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Power != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Power))
			i--
			dAtA[i] = 0x10
		}
		if len(x.Id) > 0 {
			i -= len(x.Id)
			copy(dAtA[i:], x.Id)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Signal)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Signal: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Signal: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Id = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
				}
				x.Power = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Power |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_Vote_2_list)(nil)

type _Vote_2_list struct {
	list *[]*Signal
}

func (x *_Vote_2_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_Vote_2_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_Vote_2_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*Signal)
	(*x.list)[i] = concreteValue
}

func (x *_Vote_2_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*Signal)
	*x.list = append(*x.list, concreteValue)
}

func (x *_Vote_2_list) AppendMutable() protoreflect.Value {
	v := new(Signal)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_Vote_2_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_Vote_2_list) NewElement() protoreflect.Value {
	v := new(Signal)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_Vote_2_list) IsValid() bool {
	return x.list != nil
}

var (
	md_Vote         protoreflect.MessageDescriptor
	fd_Vote_voter   protoreflect.FieldDescriptor
	fd_Vote_signals protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_Vote = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("Vote")
	fd_Vote_voter = md_Vote.Fields().ByName("voter")
	fd_Vote_signals = md_Vote.Fields().ByName("signals")
}

var _ protoreflect.Message = (*fastReflection_Vote)(nil)

type fastReflection_Vote Vote

func (x *Vote) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Vote)(x)
}

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

var _fastReflection_Vote_messageType fastReflection_Vote_messageType
var _ protoreflect.MessageType = fastReflection_Vote_messageType{}

type fastReflection_Vote_messageType struct{}

func (x fastReflection_Vote_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Vote)(nil)
}
func (x fastReflection_Vote_messageType) New() protoreflect.Message {
	return new(fastReflection_Vote)
}
func (x fastReflection_Vote_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Vote
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Vote) Descriptor() protoreflect.MessageDescriptor {
	return md_Vote
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Vote) Type() protoreflect.MessageType {
	return _fastReflection_Vote_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Vote) New() protoreflect.Message {
	return new(fastReflection_Vote)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Vote) Interface() protoreflect.ProtoMessage {
	return (*Vote)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Vote) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Voter != "" {
		value := protoreflect.ValueOfString(x.Voter)
		if !f(fd_Vote_voter, value) {
			return
		}
	}
	if len(x.Signals) != 0 {
		value := protoreflect.ValueOfList(&_Vote_2_list{list: &x.Signals})
		if !f(fd_Vote_signals, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Vote) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Vote.voter":
		return x.Voter != ""
	case "band.feeds.v1beta1.Vote.signals":
		return len(x.Signals) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Vote"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Vote does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Vote) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Vote.voter":
		x.Voter = ""
	case "band.feeds.v1beta1.Vote.signals":
		x.Signals = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Vote"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Vote does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Vote) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.Vote.voter":
		value := x.Voter
		return protoreflect.ValueOfString(value)
	case "band.feeds.v1beta1.Vote.signals":
		if len(x.Signals) == 0 {
			return protoreflect.ValueOfList(&_Vote_2_list{})
		}
		listValue := &_Vote_2_list{list: &x.Signals}
		return protoreflect.ValueOfList(listValue)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Vote"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Vote does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Vote) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Vote.voter":
		x.Voter = value.Interface().(string)
	case "band.feeds.v1beta1.Vote.signals":
		lv := value.List()
		clv := lv.(*_Vote_2_list)
		x.Signals = *clv.list
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Vote"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Vote does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Vote) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Vote.signals":
		if x.Signals == nil {
			x.Signals = []*Signal{}
		}
		value := &_Vote_2_list{list: &x.Signals}
		return protoreflect.ValueOfList(value)
	case "band.feeds.v1beta1.Vote.voter":
		panic(fmt.Errorf("field voter of message band.feeds.v1beta1.Vote is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Vote"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Vote does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Vote) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Vote.voter":
		return protoreflect.ValueOfString("")
	case "band.feeds.v1beta1.Vote.signals":
		list := []*Signal{}
		return protoreflect.ValueOfList(&_Vote_2_list{list: &list})
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Vote"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Vote does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Vote) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.Vote", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Vote) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Vote) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Vote) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Vote) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Vote)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Voter)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.Signals) > 0 {
			for _, e := range x.Signals {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Vote)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.Signals) > 0 {
			for iNdEx := len(x.Signals) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.Signals[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x12
			}
		}
		if len(x.Voter) > 0 {
			i -= len(x.Voter)
			copy(dAtA[i:], x.Voter)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Voter)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Vote)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Vote: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Vote: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Voter", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Voter = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signals", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Signals = append(x.Signals, &Signal{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Signals[len(x.Signals)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_Feed           protoreflect.MessageDescriptor
	fd_Feed_signal_id protoreflect.FieldDescriptor
	fd_Feed_power     protoreflect.FieldDescriptor
	fd_Feed_interval  protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_Feed = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("Feed")
	fd_Feed_signal_id = md_Feed.Fields().ByName("signal_id")
	fd_Feed_power = md_Feed.Fields().ByName("power")
	fd_Feed_interval = md_Feed.Fields().ByName("interval")
}

var _ protoreflect.Message = (*fastReflection_Feed)(nil)

type fastReflection_Feed Feed

func (x *Feed) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Feed)(x)
}

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

var _fastReflection_Feed_messageType fastReflection_Feed_messageType
var _ protoreflect.MessageType = fastReflection_Feed_messageType{}

type fastReflection_Feed_messageType struct{}

func (x fastReflection_Feed_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Feed)(nil)
}
func (x fastReflection_Feed_messageType) New() protoreflect.Message {
	return new(fastReflection_Feed)
}
func (x fastReflection_Feed_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Feed
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Feed) Descriptor() protoreflect.MessageDescriptor {
	return md_Feed
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Feed) Type() protoreflect.MessageType {
	return _fastReflection_Feed_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Feed) New() protoreflect.Message {
	return new(fastReflection_Feed)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Feed) Interface() protoreflect.ProtoMessage {
	return (*Feed)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Feed) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.SignalId != "" {
		value := protoreflect.ValueOfString(x.SignalId)
		if !f(fd_Feed_signal_id, value) {
			return
		}
	}
	if x.Power != int64(0) {
		value := protoreflect.ValueOfInt64(x.Power)
		if !f(fd_Feed_power, value) {
			return
		}
	}
	if x.Interval != int64(0) {
		value := protoreflect.ValueOfInt64(x.Interval)
		if !f(fd_Feed_interval, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Feed) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Feed.signal_id":
		return x.SignalId != ""
	case "band.feeds.v1beta1.Feed.power":
		return x.Power != int64(0)
	case "band.feeds.v1beta1.Feed.interval":
		return x.Interval != int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Feed"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Feed does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Feed) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Feed.signal_id":
		x.SignalId = ""
	case "band.feeds.v1beta1.Feed.power":
		x.Power = int64(0)
	case "band.feeds.v1beta1.Feed.interval":
		x.Interval = int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Feed"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Feed does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Feed) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.Feed.signal_id":
		value := x.SignalId
		return protoreflect.ValueOfString(value)
	case "band.feeds.v1beta1.Feed.power":
		value := x.Power
		return protoreflect.ValueOfInt64(value)
	case "band.feeds.v1beta1.Feed.interval":
		value := x.Interval
		return protoreflect.ValueOfInt64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Feed"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Feed does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Feed) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Feed.signal_id":
		x.SignalId = value.Interface().(string)
	case "band.feeds.v1beta1.Feed.power":
		x.Power = value.Int()
	case "band.feeds.v1beta1.Feed.interval":
		x.Interval = value.Int()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Feed"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Feed does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Feed) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Feed.signal_id":
		panic(fmt.Errorf("field signal_id of message band.feeds.v1beta1.Feed is not mutable"))
	case "band.feeds.v1beta1.Feed.power":
		panic(fmt.Errorf("field power of message band.feeds.v1beta1.Feed is not mutable"))
	case "band.feeds.v1beta1.Feed.interval":
		panic(fmt.Errorf("field interval of message band.feeds.v1beta1.Feed is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Feed"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Feed does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Feed) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Feed.signal_id":
		return protoreflect.ValueOfString("")
	case "band.feeds.v1beta1.Feed.power":
		return protoreflect.ValueOfInt64(int64(0))
	case "band.feeds.v1beta1.Feed.interval":
		return protoreflect.ValueOfInt64(int64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Feed"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Feed does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Feed) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.Feed", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Feed) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Feed) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Feed) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Feed) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Feed)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.SignalId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Power != 0 {
			n += 1 + runtime.Sov(uint64(x.Power))
		}
		if x.Interval != 0 {
			n += 1 + runtime.Sov(uint64(x.Interval))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Feed)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Interval != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Interval))
			i--
			dAtA[i] = 0x18
		}
		if x.Power != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Power))
			i--
			dAtA[i] = 0x10
		}
		if len(x.SignalId) > 0 {
			i -= len(x.SignalId)
			copy(dAtA[i:], x.SignalId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SignalId)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Feed)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Feed: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Feed: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SignalId", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.SignalId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
				}
				x.Power = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Power |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
				}
				x.Interval = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Interval |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_FeedWithDeviation                       protoreflect.MessageDescriptor
	fd_FeedWithDeviation_signal_id             protoreflect.FieldDescriptor
	fd_FeedWithDeviation_power                 protoreflect.FieldDescriptor
	fd_FeedWithDeviation_interval              protoreflect.FieldDescriptor
	fd_FeedWithDeviation_deviation_basis_point protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_FeedWithDeviation = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("FeedWithDeviation")
	fd_FeedWithDeviation_signal_id = md_FeedWithDeviation.Fields().ByName("signal_id")
	fd_FeedWithDeviation_power = md_FeedWithDeviation.Fields().ByName("power")
	fd_FeedWithDeviation_interval = md_FeedWithDeviation.Fields().ByName("interval")
	fd_FeedWithDeviation_deviation_basis_point = md_FeedWithDeviation.Fields().ByName("deviation_basis_point")
}

var _ protoreflect.Message = (*fastReflection_FeedWithDeviation)(nil)

type fastReflection_FeedWithDeviation FeedWithDeviation

func (x *FeedWithDeviation) ProtoReflect() protoreflect.Message {
	return (*fastReflection_FeedWithDeviation)(x)
}

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

var _fastReflection_FeedWithDeviation_messageType fastReflection_FeedWithDeviation_messageType
var _ protoreflect.MessageType = fastReflection_FeedWithDeviation_messageType{}

type fastReflection_FeedWithDeviation_messageType struct{}

func (x fastReflection_FeedWithDeviation_messageType) Zero() protoreflect.Message {
	return (*fastReflection_FeedWithDeviation)(nil)
}
func (x fastReflection_FeedWithDeviation_messageType) New() protoreflect.Message {
	return new(fastReflection_FeedWithDeviation)
}
func (x fastReflection_FeedWithDeviation_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_FeedWithDeviation
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_FeedWithDeviation) Descriptor() protoreflect.MessageDescriptor {
	return md_FeedWithDeviation
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_FeedWithDeviation) Type() protoreflect.MessageType {
	return _fastReflection_FeedWithDeviation_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_FeedWithDeviation) New() protoreflect.Message {
	return new(fastReflection_FeedWithDeviation)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_FeedWithDeviation) Interface() protoreflect.ProtoMessage {
	return (*FeedWithDeviation)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_FeedWithDeviation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.SignalId != "" {
		value := protoreflect.ValueOfString(x.SignalId)
		if !f(fd_FeedWithDeviation_signal_id, value) {
			return
		}
	}
	if x.Power != int64(0) {
		value := protoreflect.ValueOfInt64(x.Power)
		if !f(fd_FeedWithDeviation_power, value) {
			return
		}
	}
	if x.Interval != int64(0) {
		value := protoreflect.ValueOfInt64(x.Interval)
		if !f(fd_FeedWithDeviation_interval, value) {
			return
		}
	}
	if x.DeviationBasisPoint != int64(0) {
		value := protoreflect.ValueOfInt64(x.DeviationBasisPoint)
		if !f(fd_FeedWithDeviation_deviation_basis_point, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_FeedWithDeviation) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.FeedWithDeviation.signal_id":
		return x.SignalId != ""
	case "band.feeds.v1beta1.FeedWithDeviation.power":
		return x.Power != int64(0)
	case "band.feeds.v1beta1.FeedWithDeviation.interval":
		return x.Interval != int64(0)
	case "band.feeds.v1beta1.FeedWithDeviation.deviation_basis_point":
		return x.DeviationBasisPoint != int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedWithDeviation"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedWithDeviation does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_FeedWithDeviation) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.FeedWithDeviation.signal_id":
		x.SignalId = ""
	case "band.feeds.v1beta1.FeedWithDeviation.power":
		x.Power = int64(0)
	case "band.feeds.v1beta1.FeedWithDeviation.interval":
		x.Interval = int64(0)
	case "band.feeds.v1beta1.FeedWithDeviation.deviation_basis_point":
		x.DeviationBasisPoint = int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedWithDeviation"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedWithDeviation does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_FeedWithDeviation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.FeedWithDeviation.signal_id":
		value := x.SignalId
		return protoreflect.ValueOfString(value)
	case "band.feeds.v1beta1.FeedWithDeviation.power":
		value := x.Power
		return protoreflect.ValueOfInt64(value)
	case "band.feeds.v1beta1.FeedWithDeviation.interval":
		value := x.Interval
		return protoreflect.ValueOfInt64(value)
	case "band.feeds.v1beta1.FeedWithDeviation.deviation_basis_point":
		value := x.DeviationBasisPoint
		return protoreflect.ValueOfInt64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedWithDeviation"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedWithDeviation does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_FeedWithDeviation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.FeedWithDeviation.signal_id":
		x.SignalId = value.Interface().(string)
	case "band.feeds.v1beta1.FeedWithDeviation.power":
		x.Power = value.Int()
	case "band.feeds.v1beta1.FeedWithDeviation.interval":
		x.Interval = value.Int()
	case "band.feeds.v1beta1.FeedWithDeviation.deviation_basis_point":
		x.DeviationBasisPoint = value.Int()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedWithDeviation"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedWithDeviation does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_FeedWithDeviation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.FeedWithDeviation.signal_id":
		panic(fmt.Errorf("field signal_id of message band.feeds.v1beta1.FeedWithDeviation is not mutable"))
	case "band.feeds.v1beta1.FeedWithDeviation.power":
		panic(fmt.Errorf("field power of message band.feeds.v1beta1.FeedWithDeviation is not mutable"))
	case "band.feeds.v1beta1.FeedWithDeviation.interval":
		panic(fmt.Errorf("field interval of message band.feeds.v1beta1.FeedWithDeviation is not mutable"))
	case "band.feeds.v1beta1.FeedWithDeviation.deviation_basis_point":
		panic(fmt.Errorf("field deviation_basis_point of message band.feeds.v1beta1.FeedWithDeviation is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedWithDeviation"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedWithDeviation does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_FeedWithDeviation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.FeedWithDeviation.signal_id":
		return protoreflect.ValueOfString("")
	case "band.feeds.v1beta1.FeedWithDeviation.power":
		return protoreflect.ValueOfInt64(int64(0))
	case "band.feeds.v1beta1.FeedWithDeviation.interval":
		return protoreflect.ValueOfInt64(int64(0))
	case "band.feeds.v1beta1.FeedWithDeviation.deviation_basis_point":
		return protoreflect.ValueOfInt64(int64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedWithDeviation"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedWithDeviation does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_FeedWithDeviation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.FeedWithDeviation", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_FeedWithDeviation) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_FeedWithDeviation) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_FeedWithDeviation) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_FeedWithDeviation) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*FeedWithDeviation)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.SignalId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Power != 0 {
			n += 1 + runtime.Sov(uint64(x.Power))
		}
		if x.Interval != 0 {
			n += 1 + runtime.Sov(uint64(x.Interval))
		}
		if x.DeviationBasisPoint != 0 {
			n += 1 + runtime.Sov(uint64(x.DeviationBasisPoint))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*FeedWithDeviation)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.DeviationBasisPoint != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.DeviationBasisPoint))
			i--
			dAtA[i] = 0x20
		}
		if x.Interval != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Interval))
			i--
			dAtA[i] = 0x18
		}
		if x.Power != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Power))
			i--
			dAtA[i] = 0x10
		}
		if len(x.SignalId) > 0 {
			i -= len(x.SignalId)
			copy(dAtA[i:], x.SignalId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SignalId)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*FeedWithDeviation)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: FeedWithDeviation: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: FeedWithDeviation: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SignalId", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.SignalId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
				}
				x.Power = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Power |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
				}
				x.Interval = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Interval |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 4:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DeviationBasisPoint", wireType)
				}
				x.DeviationBasisPoint = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.DeviationBasisPoint |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_CurrentFeeds_1_list)(nil)

type _CurrentFeeds_1_list struct {
	list *[]*Feed
}

func (x *_CurrentFeeds_1_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_CurrentFeeds_1_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_CurrentFeeds_1_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*Feed)
	(*x.list)[i] = concreteValue
}

func (x *_CurrentFeeds_1_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*Feed)
	*x.list = append(*x.list, concreteValue)
}

func (x *_CurrentFeeds_1_list) AppendMutable() protoreflect.Value {
	v := new(Feed)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_CurrentFeeds_1_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_CurrentFeeds_1_list) NewElement() protoreflect.Value {
	v := new(Feed)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_CurrentFeeds_1_list) IsValid() bool {
	return x.list != nil
}

var (
	md_CurrentFeeds                       protoreflect.MessageDescriptor
	fd_CurrentFeeds_feeds                 protoreflect.FieldDescriptor
	fd_CurrentFeeds_last_update_timestamp protoreflect.FieldDescriptor
	fd_CurrentFeeds_last_update_block     protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_CurrentFeeds = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("CurrentFeeds")
	fd_CurrentFeeds_feeds = md_CurrentFeeds.Fields().ByName("feeds")
	fd_CurrentFeeds_last_update_timestamp = md_CurrentFeeds.Fields().ByName("last_update_timestamp")
	fd_CurrentFeeds_last_update_block = md_CurrentFeeds.Fields().ByName("last_update_block")
}

var _ protoreflect.Message = (*fastReflection_CurrentFeeds)(nil)

type fastReflection_CurrentFeeds CurrentFeeds

func (x *CurrentFeeds) ProtoReflect() protoreflect.Message {
	return (*fastReflection_CurrentFeeds)(x)
}

func (x *CurrentFeeds) slowProtoReflect() protoreflect.Message {
	mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[4]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_CurrentFeeds_messageType fastReflection_CurrentFeeds_messageType
var _ protoreflect.MessageType = fastReflection_CurrentFeeds_messageType{}

type fastReflection_CurrentFeeds_messageType struct{}

func (x fastReflection_CurrentFeeds_messageType) Zero() protoreflect.Message {
	return (*fastReflection_CurrentFeeds)(nil)
}
func (x fastReflection_CurrentFeeds_messageType) New() protoreflect.Message {
	return new(fastReflection_CurrentFeeds)
}
func (x fastReflection_CurrentFeeds_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_CurrentFeeds
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_CurrentFeeds) Descriptor() protoreflect.MessageDescriptor {
	return md_CurrentFeeds
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_CurrentFeeds) Type() protoreflect.MessageType {
	return _fastReflection_CurrentFeeds_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_CurrentFeeds) New() protoreflect.Message {
	return new(fastReflection_CurrentFeeds)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_CurrentFeeds) Interface() protoreflect.ProtoMessage {
	return (*CurrentFeeds)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_CurrentFeeds) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if len(x.Feeds) != 0 {
		value := protoreflect.ValueOfList(&_CurrentFeeds_1_list{list: &x.Feeds})
		if !f(fd_CurrentFeeds_feeds, value) {
			return
		}
	}
	if x.LastUpdateTimestamp != int64(0) {
		value := protoreflect.ValueOfInt64(x.LastUpdateTimestamp)
		if !f(fd_CurrentFeeds_last_update_timestamp, value) {
			return
		}
	}
	if x.LastUpdateBlock != int64(0) {
		value := protoreflect.ValueOfInt64(x.LastUpdateBlock)
		if !f(fd_CurrentFeeds_last_update_block, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_CurrentFeeds) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.CurrentFeeds.feeds":
		return len(x.Feeds) != 0
	case "band.feeds.v1beta1.CurrentFeeds.last_update_timestamp":
		return x.LastUpdateTimestamp != int64(0)
	case "band.feeds.v1beta1.CurrentFeeds.last_update_block":
		return x.LastUpdateBlock != int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeeds"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeeds does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_CurrentFeeds) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.CurrentFeeds.feeds":
		x.Feeds = nil
	case "band.feeds.v1beta1.CurrentFeeds.last_update_timestamp":
		x.LastUpdateTimestamp = int64(0)
	case "band.feeds.v1beta1.CurrentFeeds.last_update_block":
		x.LastUpdateBlock = int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeeds"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeeds does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_CurrentFeeds) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.CurrentFeeds.feeds":
		if len(x.Feeds) == 0 {
			return protoreflect.ValueOfList(&_CurrentFeeds_1_list{})
		}
		listValue := &_CurrentFeeds_1_list{list: &x.Feeds}
		return protoreflect.ValueOfList(listValue)
	case "band.feeds.v1beta1.CurrentFeeds.last_update_timestamp":
		value := x.LastUpdateTimestamp
		return protoreflect.ValueOfInt64(value)
	case "band.feeds.v1beta1.CurrentFeeds.last_update_block":
		value := x.LastUpdateBlock
		return protoreflect.ValueOfInt64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeeds"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeeds does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_CurrentFeeds) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.CurrentFeeds.feeds":
		lv := value.List()
		clv := lv.(*_CurrentFeeds_1_list)
		x.Feeds = *clv.list
	case "band.feeds.v1beta1.CurrentFeeds.last_update_timestamp":
		x.LastUpdateTimestamp = value.Int()
	case "band.feeds.v1beta1.CurrentFeeds.last_update_block":
		x.LastUpdateBlock = value.Int()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeeds"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeeds does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_CurrentFeeds) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.CurrentFeeds.feeds":
		if x.Feeds == nil {
			x.Feeds = []*Feed{}
		}
		value := &_CurrentFeeds_1_list{list: &x.Feeds}
		return protoreflect.ValueOfList(value)
	case "band.feeds.v1beta1.CurrentFeeds.last_update_timestamp":
		panic(fmt.Errorf("field last_update_timestamp of message band.feeds.v1beta1.CurrentFeeds is not mutable"))
	case "band.feeds.v1beta1.CurrentFeeds.last_update_block":
		panic(fmt.Errorf("field last_update_block of message band.feeds.v1beta1.CurrentFeeds is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeeds"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeeds does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_CurrentFeeds) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.CurrentFeeds.feeds":
		list := []*Feed{}
		return protoreflect.ValueOfList(&_CurrentFeeds_1_list{list: &list})
	case "band.feeds.v1beta1.CurrentFeeds.last_update_timestamp":
		return protoreflect.ValueOfInt64(int64(0))
	case "band.feeds.v1beta1.CurrentFeeds.last_update_block":
		return protoreflect.ValueOfInt64(int64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeeds"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeeds does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_CurrentFeeds) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.CurrentFeeds", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_CurrentFeeds) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_CurrentFeeds) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_CurrentFeeds) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_CurrentFeeds) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*CurrentFeeds)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if len(x.Feeds) > 0 {
			for _, e := range x.Feeds {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.LastUpdateTimestamp != 0 {
			n += 1 + runtime.Sov(uint64(x.LastUpdateTimestamp))
		}
		if x.LastUpdateBlock != 0 {
			n += 1 + runtime.Sov(uint64(x.LastUpdateBlock))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*CurrentFeeds)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.LastUpdateBlock != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.LastUpdateBlock))
			i--
			dAtA[i] = 0x18
		}
		if x.LastUpdateTimestamp != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.LastUpdateTimestamp))
			i--
			dAtA[i] = 0x10
		}
		if len(x.Feeds) > 0 {
			for iNdEx := len(x.Feeds) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.Feeds[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0xa
			}
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*CurrentFeeds)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CurrentFeeds: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CurrentFeeds: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Feeds", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Feeds = append(x.Feeds, &Feed{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Feeds[len(x.Feeds)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTimestamp", wireType)
				}
				x.LastUpdateTimestamp = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.LastUpdateTimestamp |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LastUpdateBlock", wireType)
				}
				x.LastUpdateBlock = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.LastUpdateBlock |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_CurrentFeedWithDeviations_1_list)(nil)

type _CurrentFeedWithDeviations_1_list struct {
	list *[]*FeedWithDeviation
}

func (x *_CurrentFeedWithDeviations_1_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_CurrentFeedWithDeviations_1_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_CurrentFeedWithDeviations_1_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*FeedWithDeviation)
	(*x.list)[i] = concreteValue
}

func (x *_CurrentFeedWithDeviations_1_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*FeedWithDeviation)
	*x.list = append(*x.list, concreteValue)
}

func (x *_CurrentFeedWithDeviations_1_list) AppendMutable() protoreflect.Value {
	v := new(FeedWithDeviation)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_CurrentFeedWithDeviations_1_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_CurrentFeedWithDeviations_1_list) NewElement() protoreflect.Value {
	v := new(FeedWithDeviation)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_CurrentFeedWithDeviations_1_list) IsValid() bool {
	return x.list != nil
}

var (
	md_CurrentFeedWithDeviations                       protoreflect.MessageDescriptor
	fd_CurrentFeedWithDeviations_feeds                 protoreflect.FieldDescriptor
	fd_CurrentFeedWithDeviations_last_update_timestamp protoreflect.FieldDescriptor
	fd_CurrentFeedWithDeviations_last_update_block     protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_CurrentFeedWithDeviations = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("CurrentFeedWithDeviations")
	fd_CurrentFeedWithDeviations_feeds = md_CurrentFeedWithDeviations.Fields().ByName("feeds")
	fd_CurrentFeedWithDeviations_last_update_timestamp = md_CurrentFeedWithDeviations.Fields().ByName("last_update_timestamp")
	fd_CurrentFeedWithDeviations_last_update_block = md_CurrentFeedWithDeviations.Fields().ByName("last_update_block")
}

var _ protoreflect.Message = (*fastReflection_CurrentFeedWithDeviations)(nil)

type fastReflection_CurrentFeedWithDeviations CurrentFeedWithDeviations

func (x *CurrentFeedWithDeviations) ProtoReflect() protoreflect.Message {
	return (*fastReflection_CurrentFeedWithDeviations)(x)
}

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

var _fastReflection_CurrentFeedWithDeviations_messageType fastReflection_CurrentFeedWithDeviations_messageType
var _ protoreflect.MessageType = fastReflection_CurrentFeedWithDeviations_messageType{}

type fastReflection_CurrentFeedWithDeviations_messageType struct{}

func (x fastReflection_CurrentFeedWithDeviations_messageType) Zero() protoreflect.Message {
	return (*fastReflection_CurrentFeedWithDeviations)(nil)
}
func (x fastReflection_CurrentFeedWithDeviations_messageType) New() protoreflect.Message {
	return new(fastReflection_CurrentFeedWithDeviations)
}
func (x fastReflection_CurrentFeedWithDeviations_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_CurrentFeedWithDeviations
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_CurrentFeedWithDeviations) Descriptor() protoreflect.MessageDescriptor {
	return md_CurrentFeedWithDeviations
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_CurrentFeedWithDeviations) Type() protoreflect.MessageType {
	return _fastReflection_CurrentFeedWithDeviations_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_CurrentFeedWithDeviations) New() protoreflect.Message {
	return new(fastReflection_CurrentFeedWithDeviations)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_CurrentFeedWithDeviations) Interface() protoreflect.ProtoMessage {
	return (*CurrentFeedWithDeviations)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_CurrentFeedWithDeviations) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if len(x.Feeds) != 0 {
		value := protoreflect.ValueOfList(&_CurrentFeedWithDeviations_1_list{list: &x.Feeds})
		if !f(fd_CurrentFeedWithDeviations_feeds, value) {
			return
		}
	}
	if x.LastUpdateTimestamp != int64(0) {
		value := protoreflect.ValueOfInt64(x.LastUpdateTimestamp)
		if !f(fd_CurrentFeedWithDeviations_last_update_timestamp, value) {
			return
		}
	}
	if x.LastUpdateBlock != int64(0) {
		value := protoreflect.ValueOfInt64(x.LastUpdateBlock)
		if !f(fd_CurrentFeedWithDeviations_last_update_block, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_CurrentFeedWithDeviations) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.feeds":
		return len(x.Feeds) != 0
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_timestamp":
		return x.LastUpdateTimestamp != int64(0)
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_block":
		return x.LastUpdateBlock != int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeedWithDeviations"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeedWithDeviations does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_CurrentFeedWithDeviations) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.feeds":
		x.Feeds = nil
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_timestamp":
		x.LastUpdateTimestamp = int64(0)
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_block":
		x.LastUpdateBlock = int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeedWithDeviations"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeedWithDeviations does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_CurrentFeedWithDeviations) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.feeds":
		if len(x.Feeds) == 0 {
			return protoreflect.ValueOfList(&_CurrentFeedWithDeviations_1_list{})
		}
		listValue := &_CurrentFeedWithDeviations_1_list{list: &x.Feeds}
		return protoreflect.ValueOfList(listValue)
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_timestamp":
		value := x.LastUpdateTimestamp
		return protoreflect.ValueOfInt64(value)
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_block":
		value := x.LastUpdateBlock
		return protoreflect.ValueOfInt64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeedWithDeviations"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeedWithDeviations does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_CurrentFeedWithDeviations) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.feeds":
		lv := value.List()
		clv := lv.(*_CurrentFeedWithDeviations_1_list)
		x.Feeds = *clv.list
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_timestamp":
		x.LastUpdateTimestamp = value.Int()
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_block":
		x.LastUpdateBlock = value.Int()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeedWithDeviations"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeedWithDeviations does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_CurrentFeedWithDeviations) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.feeds":
		if x.Feeds == nil {
			x.Feeds = []*FeedWithDeviation{}
		}
		value := &_CurrentFeedWithDeviations_1_list{list: &x.Feeds}
		return protoreflect.ValueOfList(value)
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_timestamp":
		panic(fmt.Errorf("field last_update_timestamp of message band.feeds.v1beta1.CurrentFeedWithDeviations is not mutable"))
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_block":
		panic(fmt.Errorf("field last_update_block of message band.feeds.v1beta1.CurrentFeedWithDeviations is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeedWithDeviations"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeedWithDeviations does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_CurrentFeedWithDeviations) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.feeds":
		list := []*FeedWithDeviation{}
		return protoreflect.ValueOfList(&_CurrentFeedWithDeviations_1_list{list: &list})
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_timestamp":
		return protoreflect.ValueOfInt64(int64(0))
	case "band.feeds.v1beta1.CurrentFeedWithDeviations.last_update_block":
		return protoreflect.ValueOfInt64(int64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.CurrentFeedWithDeviations"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.CurrentFeedWithDeviations does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_CurrentFeedWithDeviations) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.CurrentFeedWithDeviations", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_CurrentFeedWithDeviations) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_CurrentFeedWithDeviations) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_CurrentFeedWithDeviations) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_CurrentFeedWithDeviations) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*CurrentFeedWithDeviations)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if len(x.Feeds) > 0 {
			for _, e := range x.Feeds {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.LastUpdateTimestamp != 0 {
			n += 1 + runtime.Sov(uint64(x.LastUpdateTimestamp))
		}
		if x.LastUpdateBlock != 0 {
			n += 1 + runtime.Sov(uint64(x.LastUpdateBlock))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*CurrentFeedWithDeviations)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.LastUpdateBlock != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.LastUpdateBlock))
			i--
			dAtA[i] = 0x18
		}
		if x.LastUpdateTimestamp != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.LastUpdateTimestamp))
			i--
			dAtA[i] = 0x10
		}
		if len(x.Feeds) > 0 {
			for iNdEx := len(x.Feeds) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.Feeds[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0xa
			}
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*CurrentFeedWithDeviations)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CurrentFeedWithDeviations: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CurrentFeedWithDeviations: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Feeds", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Feeds = append(x.Feeds, &FeedWithDeviation{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Feeds[len(x.Feeds)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTimestamp", wireType)
				}
				x.LastUpdateTimestamp = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.LastUpdateTimestamp |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LastUpdateBlock", wireType)
				}
				x.LastUpdateBlock = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.LastUpdateBlock |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_Price           protoreflect.MessageDescriptor
	fd_Price_status    protoreflect.FieldDescriptor
	fd_Price_signal_id protoreflect.FieldDescriptor
	fd_Price_price     protoreflect.FieldDescriptor
	fd_Price_timestamp protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_Price = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("Price")
	fd_Price_status = md_Price.Fields().ByName("status")
	fd_Price_signal_id = md_Price.Fields().ByName("signal_id")
	fd_Price_price = md_Price.Fields().ByName("price")
	fd_Price_timestamp = md_Price.Fields().ByName("timestamp")
}

var _ protoreflect.Message = (*fastReflection_Price)(nil)

type fastReflection_Price Price

func (x *Price) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Price)(x)
}

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

var _fastReflection_Price_messageType fastReflection_Price_messageType
var _ protoreflect.MessageType = fastReflection_Price_messageType{}

type fastReflection_Price_messageType struct{}

func (x fastReflection_Price_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Price)(nil)
}
func (x fastReflection_Price_messageType) New() protoreflect.Message {
	return new(fastReflection_Price)
}
func (x fastReflection_Price_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Price
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Price) Descriptor() protoreflect.MessageDescriptor {
	return md_Price
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Price) Type() protoreflect.MessageType {
	return _fastReflection_Price_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Price) New() protoreflect.Message {
	return new(fastReflection_Price)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Price) Interface() protoreflect.ProtoMessage {
	return (*Price)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Price) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Status != 0 {
		value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
		if !f(fd_Price_status, value) {
			return
		}
	}
	if x.SignalId != "" {
		value := protoreflect.ValueOfString(x.SignalId)
		if !f(fd_Price_signal_id, value) {
			return
		}
	}
	if x.Price != uint64(0) {
		value := protoreflect.ValueOfUint64(x.Price)
		if !f(fd_Price_price, value) {
			return
		}
	}
	if x.Timestamp != int64(0) {
		value := protoreflect.ValueOfInt64(x.Timestamp)
		if !f(fd_Price_timestamp, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Price) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Price.status":
		return x.Status != 0
	case "band.feeds.v1beta1.Price.signal_id":
		return x.SignalId != ""
	case "band.feeds.v1beta1.Price.price":
		return x.Price != uint64(0)
	case "band.feeds.v1beta1.Price.timestamp":
		return x.Timestamp != int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Price"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Price does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Price) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Price.status":
		x.Status = 0
	case "band.feeds.v1beta1.Price.signal_id":
		x.SignalId = ""
	case "band.feeds.v1beta1.Price.price":
		x.Price = uint64(0)
	case "band.feeds.v1beta1.Price.timestamp":
		x.Timestamp = int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Price"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Price does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Price) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.Price.status":
		value := x.Status
		return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
	case "band.feeds.v1beta1.Price.signal_id":
		value := x.SignalId
		return protoreflect.ValueOfString(value)
	case "band.feeds.v1beta1.Price.price":
		value := x.Price
		return protoreflect.ValueOfUint64(value)
	case "band.feeds.v1beta1.Price.timestamp":
		value := x.Timestamp
		return protoreflect.ValueOfInt64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Price"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Price does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Price) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Price.status":
		x.Status = (PriceStatus)(value.Enum())
	case "band.feeds.v1beta1.Price.signal_id":
		x.SignalId = value.Interface().(string)
	case "band.feeds.v1beta1.Price.price":
		x.Price = value.Uint()
	case "band.feeds.v1beta1.Price.timestamp":
		x.Timestamp = value.Int()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Price"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Price does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Price) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Price.status":
		panic(fmt.Errorf("field status of message band.feeds.v1beta1.Price is not mutable"))
	case "band.feeds.v1beta1.Price.signal_id":
		panic(fmt.Errorf("field signal_id of message band.feeds.v1beta1.Price is not mutable"))
	case "band.feeds.v1beta1.Price.price":
		panic(fmt.Errorf("field price of message band.feeds.v1beta1.Price is not mutable"))
	case "band.feeds.v1beta1.Price.timestamp":
		panic(fmt.Errorf("field timestamp of message band.feeds.v1beta1.Price is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Price"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Price does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Price) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.Price.status":
		return protoreflect.ValueOfEnum(0)
	case "band.feeds.v1beta1.Price.signal_id":
		return protoreflect.ValueOfString("")
	case "band.feeds.v1beta1.Price.price":
		return protoreflect.ValueOfUint64(uint64(0))
	case "band.feeds.v1beta1.Price.timestamp":
		return protoreflect.ValueOfInt64(int64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.Price"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.Price does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Price) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.Price", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Price) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Price) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Price) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Price) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Price)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Status != 0 {
			n += 1 + runtime.Sov(uint64(x.Status))
		}
		l = len(x.SignalId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Price != 0 {
			n += 1 + runtime.Sov(uint64(x.Price))
		}
		if x.Timestamp != 0 {
			n += 1 + runtime.Sov(uint64(x.Timestamp))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Price)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Timestamp != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Timestamp))
			i--
			dAtA[i] = 0x20
		}
		if x.Price != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Price))
			i--
			dAtA[i] = 0x18
		}
		if len(x.SignalId) > 0 {
			i -= len(x.SignalId)
			copy(dAtA[i:], x.SignalId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SignalId)))
			i--
			dAtA[i] = 0x12
		}
		if x.Status != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Price)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Price: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Price: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
				}
				x.Status = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Status |= PriceStatus(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SignalId", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.SignalId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
				}
				x.Price = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Price |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 4:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
				}
				x.Timestamp = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Timestamp |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_SignalPrice           protoreflect.MessageDescriptor
	fd_SignalPrice_status    protoreflect.FieldDescriptor
	fd_SignalPrice_signal_id protoreflect.FieldDescriptor
	fd_SignalPrice_price     protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_SignalPrice = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("SignalPrice")
	fd_SignalPrice_status = md_SignalPrice.Fields().ByName("status")
	fd_SignalPrice_signal_id = md_SignalPrice.Fields().ByName("signal_id")
	fd_SignalPrice_price = md_SignalPrice.Fields().ByName("price")
}

var _ protoreflect.Message = (*fastReflection_SignalPrice)(nil)

type fastReflection_SignalPrice SignalPrice

func (x *SignalPrice) ProtoReflect() protoreflect.Message {
	return (*fastReflection_SignalPrice)(x)
}

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

var _fastReflection_SignalPrice_messageType fastReflection_SignalPrice_messageType
var _ protoreflect.MessageType = fastReflection_SignalPrice_messageType{}

type fastReflection_SignalPrice_messageType struct{}

func (x fastReflection_SignalPrice_messageType) Zero() protoreflect.Message {
	return (*fastReflection_SignalPrice)(nil)
}
func (x fastReflection_SignalPrice_messageType) New() protoreflect.Message {
	return new(fastReflection_SignalPrice)
}
func (x fastReflection_SignalPrice_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_SignalPrice
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_SignalPrice) Descriptor() protoreflect.MessageDescriptor {
	return md_SignalPrice
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_SignalPrice) Type() protoreflect.MessageType {
	return _fastReflection_SignalPrice_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_SignalPrice) New() protoreflect.Message {
	return new(fastReflection_SignalPrice)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_SignalPrice) Interface() protoreflect.ProtoMessage {
	return (*SignalPrice)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_SignalPrice) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Status != 0 {
		value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
		if !f(fd_SignalPrice_status, value) {
			return
		}
	}
	if x.SignalId != "" {
		value := protoreflect.ValueOfString(x.SignalId)
		if !f(fd_SignalPrice_signal_id, value) {
			return
		}
	}
	if x.Price != uint64(0) {
		value := protoreflect.ValueOfUint64(x.Price)
		if !f(fd_SignalPrice_price, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_SignalPrice) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.SignalPrice.status":
		return x.Status != 0
	case "band.feeds.v1beta1.SignalPrice.signal_id":
		return x.SignalId != ""
	case "band.feeds.v1beta1.SignalPrice.price":
		return x.Price != uint64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.SignalPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.SignalPrice does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_SignalPrice) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.SignalPrice.status":
		x.Status = 0
	case "band.feeds.v1beta1.SignalPrice.signal_id":
		x.SignalId = ""
	case "band.feeds.v1beta1.SignalPrice.price":
		x.Price = uint64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.SignalPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.SignalPrice does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_SignalPrice) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.SignalPrice.status":
		value := x.Status
		return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
	case "band.feeds.v1beta1.SignalPrice.signal_id":
		value := x.SignalId
		return protoreflect.ValueOfString(value)
	case "band.feeds.v1beta1.SignalPrice.price":
		value := x.Price
		return protoreflect.ValueOfUint64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.SignalPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.SignalPrice does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_SignalPrice) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.SignalPrice.status":
		x.Status = (SignalPriceStatus)(value.Enum())
	case "band.feeds.v1beta1.SignalPrice.signal_id":
		x.SignalId = value.Interface().(string)
	case "band.feeds.v1beta1.SignalPrice.price":
		x.Price = value.Uint()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.SignalPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.SignalPrice does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_SignalPrice) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.SignalPrice.status":
		panic(fmt.Errorf("field status of message band.feeds.v1beta1.SignalPrice is not mutable"))
	case "band.feeds.v1beta1.SignalPrice.signal_id":
		panic(fmt.Errorf("field signal_id of message band.feeds.v1beta1.SignalPrice is not mutable"))
	case "band.feeds.v1beta1.SignalPrice.price":
		panic(fmt.Errorf("field price of message band.feeds.v1beta1.SignalPrice is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.SignalPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.SignalPrice does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_SignalPrice) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.SignalPrice.status":
		return protoreflect.ValueOfEnum(0)
	case "band.feeds.v1beta1.SignalPrice.signal_id":
		return protoreflect.ValueOfString("")
	case "band.feeds.v1beta1.SignalPrice.price":
		return protoreflect.ValueOfUint64(uint64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.SignalPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.SignalPrice does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_SignalPrice) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.SignalPrice", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_SignalPrice) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_SignalPrice) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_SignalPrice) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_SignalPrice) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*SignalPrice)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Status != 0 {
			n += 1 + runtime.Sov(uint64(x.Status))
		}
		l = len(x.SignalId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Price != 0 {
			n += 1 + runtime.Sov(uint64(x.Price))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*SignalPrice)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Price != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Price))
			i--
			dAtA[i] = 0x18
		}
		if len(x.SignalId) > 0 {
			i -= len(x.SignalId)
			copy(dAtA[i:], x.SignalId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SignalId)))
			i--
			dAtA[i] = 0x12
		}
		if x.Status != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*SignalPrice)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: SignalPrice: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: SignalPrice: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
				}
				x.Status = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Status |= SignalPriceStatus(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SignalId", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.SignalId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
				}
				x.Price = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Price |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_ValidatorPrice                     protoreflect.MessageDescriptor
	fd_ValidatorPrice_signal_price_status protoreflect.FieldDescriptor
	fd_ValidatorPrice_signal_id           protoreflect.FieldDescriptor
	fd_ValidatorPrice_price               protoreflect.FieldDescriptor
	fd_ValidatorPrice_timestamp           protoreflect.FieldDescriptor
	fd_ValidatorPrice_block_height        protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_ValidatorPrice = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("ValidatorPrice")
	fd_ValidatorPrice_signal_price_status = md_ValidatorPrice.Fields().ByName("signal_price_status")
	fd_ValidatorPrice_signal_id = md_ValidatorPrice.Fields().ByName("signal_id")
	fd_ValidatorPrice_price = md_ValidatorPrice.Fields().ByName("price")
	fd_ValidatorPrice_timestamp = md_ValidatorPrice.Fields().ByName("timestamp")
	fd_ValidatorPrice_block_height = md_ValidatorPrice.Fields().ByName("block_height")
}

var _ protoreflect.Message = (*fastReflection_ValidatorPrice)(nil)

type fastReflection_ValidatorPrice ValidatorPrice

func (x *ValidatorPrice) ProtoReflect() protoreflect.Message {
	return (*fastReflection_ValidatorPrice)(x)
}

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

var _fastReflection_ValidatorPrice_messageType fastReflection_ValidatorPrice_messageType
var _ protoreflect.MessageType = fastReflection_ValidatorPrice_messageType{}

type fastReflection_ValidatorPrice_messageType struct{}

func (x fastReflection_ValidatorPrice_messageType) Zero() protoreflect.Message {
	return (*fastReflection_ValidatorPrice)(nil)
}
func (x fastReflection_ValidatorPrice_messageType) New() protoreflect.Message {
	return new(fastReflection_ValidatorPrice)
}
func (x fastReflection_ValidatorPrice_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_ValidatorPrice
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_ValidatorPrice) Descriptor() protoreflect.MessageDescriptor {
	return md_ValidatorPrice
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_ValidatorPrice) Type() protoreflect.MessageType {
	return _fastReflection_ValidatorPrice_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_ValidatorPrice) New() protoreflect.Message {
	return new(fastReflection_ValidatorPrice)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_ValidatorPrice) Interface() protoreflect.ProtoMessage {
	return (*ValidatorPrice)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_ValidatorPrice) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.SignalPriceStatus != 0 {
		value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.SignalPriceStatus))
		if !f(fd_ValidatorPrice_signal_price_status, value) {
			return
		}
	}
	if x.SignalId != "" {
		value := protoreflect.ValueOfString(x.SignalId)
		if !f(fd_ValidatorPrice_signal_id, value) {
			return
		}
	}
	if x.Price != uint64(0) {
		value := protoreflect.ValueOfUint64(x.Price)
		if !f(fd_ValidatorPrice_price, value) {
			return
		}
	}
	if x.Timestamp != int64(0) {
		value := protoreflect.ValueOfInt64(x.Timestamp)
		if !f(fd_ValidatorPrice_timestamp, value) {
			return
		}
	}
	if x.BlockHeight != int64(0) {
		value := protoreflect.ValueOfInt64(x.BlockHeight)
		if !f(fd_ValidatorPrice_block_height, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_ValidatorPrice) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ValidatorPrice.signal_price_status":
		return x.SignalPriceStatus != 0
	case "band.feeds.v1beta1.ValidatorPrice.signal_id":
		return x.SignalId != ""
	case "band.feeds.v1beta1.ValidatorPrice.price":
		return x.Price != uint64(0)
	case "band.feeds.v1beta1.ValidatorPrice.timestamp":
		return x.Timestamp != int64(0)
	case "band.feeds.v1beta1.ValidatorPrice.block_height":
		return x.BlockHeight != int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPrice does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ValidatorPrice) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ValidatorPrice.signal_price_status":
		x.SignalPriceStatus = 0
	case "band.feeds.v1beta1.ValidatorPrice.signal_id":
		x.SignalId = ""
	case "band.feeds.v1beta1.ValidatorPrice.price":
		x.Price = uint64(0)
	case "band.feeds.v1beta1.ValidatorPrice.timestamp":
		x.Timestamp = int64(0)
	case "band.feeds.v1beta1.ValidatorPrice.block_height":
		x.BlockHeight = int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPrice does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_ValidatorPrice) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.ValidatorPrice.signal_price_status":
		value := x.SignalPriceStatus
		return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
	case "band.feeds.v1beta1.ValidatorPrice.signal_id":
		value := x.SignalId
		return protoreflect.ValueOfString(value)
	case "band.feeds.v1beta1.ValidatorPrice.price":
		value := x.Price
		return protoreflect.ValueOfUint64(value)
	case "band.feeds.v1beta1.ValidatorPrice.timestamp":
		value := x.Timestamp
		return protoreflect.ValueOfInt64(value)
	case "band.feeds.v1beta1.ValidatorPrice.block_height":
		value := x.BlockHeight
		return protoreflect.ValueOfInt64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPrice does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ValidatorPrice) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ValidatorPrice.signal_price_status":
		x.SignalPriceStatus = (SignalPriceStatus)(value.Enum())
	case "band.feeds.v1beta1.ValidatorPrice.signal_id":
		x.SignalId = value.Interface().(string)
	case "band.feeds.v1beta1.ValidatorPrice.price":
		x.Price = value.Uint()
	case "band.feeds.v1beta1.ValidatorPrice.timestamp":
		x.Timestamp = value.Int()
	case "band.feeds.v1beta1.ValidatorPrice.block_height":
		x.BlockHeight = value.Int()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPrice does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ValidatorPrice) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ValidatorPrice.signal_price_status":
		panic(fmt.Errorf("field signal_price_status of message band.feeds.v1beta1.ValidatorPrice is not mutable"))
	case "band.feeds.v1beta1.ValidatorPrice.signal_id":
		panic(fmt.Errorf("field signal_id of message band.feeds.v1beta1.ValidatorPrice is not mutable"))
	case "band.feeds.v1beta1.ValidatorPrice.price":
		panic(fmt.Errorf("field price of message band.feeds.v1beta1.ValidatorPrice is not mutable"))
	case "band.feeds.v1beta1.ValidatorPrice.timestamp":
		panic(fmt.Errorf("field timestamp of message band.feeds.v1beta1.ValidatorPrice is not mutable"))
	case "band.feeds.v1beta1.ValidatorPrice.block_height":
		panic(fmt.Errorf("field block_height of message band.feeds.v1beta1.ValidatorPrice is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPrice does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_ValidatorPrice) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ValidatorPrice.signal_price_status":
		return protoreflect.ValueOfEnum(0)
	case "band.feeds.v1beta1.ValidatorPrice.signal_id":
		return protoreflect.ValueOfString("")
	case "band.feeds.v1beta1.ValidatorPrice.price":
		return protoreflect.ValueOfUint64(uint64(0))
	case "band.feeds.v1beta1.ValidatorPrice.timestamp":
		return protoreflect.ValueOfInt64(int64(0))
	case "band.feeds.v1beta1.ValidatorPrice.block_height":
		return protoreflect.ValueOfInt64(int64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPrice"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPrice does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_ValidatorPrice) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.ValidatorPrice", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_ValidatorPrice) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ValidatorPrice) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_ValidatorPrice) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_ValidatorPrice) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*ValidatorPrice)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.SignalPriceStatus != 0 {
			n += 1 + runtime.Sov(uint64(x.SignalPriceStatus))
		}
		l = len(x.SignalId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Price != 0 {
			n += 1 + runtime.Sov(uint64(x.Price))
		}
		if x.Timestamp != 0 {
			n += 1 + runtime.Sov(uint64(x.Timestamp))
		}
		if x.BlockHeight != 0 {
			n += 1 + runtime.Sov(uint64(x.BlockHeight))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*ValidatorPrice)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.BlockHeight != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
			i--
			dAtA[i] = 0x28
		}
		if x.Timestamp != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Timestamp))
			i--
			dAtA[i] = 0x20
		}
		if x.Price != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Price))
			i--
			dAtA[i] = 0x18
		}
		if len(x.SignalId) > 0 {
			i -= len(x.SignalId)
			copy(dAtA[i:], x.SignalId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SignalId)))
			i--
			dAtA[i] = 0x12
		}
		if x.SignalPriceStatus != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.SignalPriceStatus))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*ValidatorPrice)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorPrice: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorPrice: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SignalPriceStatus", wireType)
				}
				x.SignalPriceStatus = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.SignalPriceStatus |= SignalPriceStatus(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SignalId", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.SignalId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
				}
				x.Price = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Price |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 4:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
				}
				x.Timestamp = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Timestamp |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 5:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
				}
				x.BlockHeight = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.BlockHeight |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_ValidatorPriceList_2_list)(nil)

type _ValidatorPriceList_2_list struct {
	list *[]*ValidatorPrice
}

func (x *_ValidatorPriceList_2_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_ValidatorPriceList_2_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_ValidatorPriceList_2_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*ValidatorPrice)
	(*x.list)[i] = concreteValue
}

func (x *_ValidatorPriceList_2_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*ValidatorPrice)
	*x.list = append(*x.list, concreteValue)
}

func (x *_ValidatorPriceList_2_list) AppendMutable() protoreflect.Value {
	v := new(ValidatorPrice)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_ValidatorPriceList_2_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_ValidatorPriceList_2_list) NewElement() protoreflect.Value {
	v := new(ValidatorPrice)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_ValidatorPriceList_2_list) IsValid() bool {
	return x.list != nil
}

var (
	md_ValidatorPriceList                  protoreflect.MessageDescriptor
	fd_ValidatorPriceList_validator        protoreflect.FieldDescriptor
	fd_ValidatorPriceList_validator_prices protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_ValidatorPriceList = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("ValidatorPriceList")
	fd_ValidatorPriceList_validator = md_ValidatorPriceList.Fields().ByName("validator")
	fd_ValidatorPriceList_validator_prices = md_ValidatorPriceList.Fields().ByName("validator_prices")
}

var _ protoreflect.Message = (*fastReflection_ValidatorPriceList)(nil)

type fastReflection_ValidatorPriceList ValidatorPriceList

func (x *ValidatorPriceList) ProtoReflect() protoreflect.Message {
	return (*fastReflection_ValidatorPriceList)(x)
}

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

var _fastReflection_ValidatorPriceList_messageType fastReflection_ValidatorPriceList_messageType
var _ protoreflect.MessageType = fastReflection_ValidatorPriceList_messageType{}

type fastReflection_ValidatorPriceList_messageType struct{}

func (x fastReflection_ValidatorPriceList_messageType) Zero() protoreflect.Message {
	return (*fastReflection_ValidatorPriceList)(nil)
}
func (x fastReflection_ValidatorPriceList_messageType) New() protoreflect.Message {
	return new(fastReflection_ValidatorPriceList)
}
func (x fastReflection_ValidatorPriceList_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_ValidatorPriceList
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_ValidatorPriceList) Descriptor() protoreflect.MessageDescriptor {
	return md_ValidatorPriceList
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_ValidatorPriceList) Type() protoreflect.MessageType {
	return _fastReflection_ValidatorPriceList_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_ValidatorPriceList) New() protoreflect.Message {
	return new(fastReflection_ValidatorPriceList)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_ValidatorPriceList) Interface() protoreflect.ProtoMessage {
	return (*ValidatorPriceList)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_ValidatorPriceList) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Validator != "" {
		value := protoreflect.ValueOfString(x.Validator)
		if !f(fd_ValidatorPriceList_validator, value) {
			return
		}
	}
	if len(x.ValidatorPrices) != 0 {
		value := protoreflect.ValueOfList(&_ValidatorPriceList_2_list{list: &x.ValidatorPrices})
		if !f(fd_ValidatorPriceList_validator_prices, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_ValidatorPriceList) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ValidatorPriceList.validator":
		return x.Validator != ""
	case "band.feeds.v1beta1.ValidatorPriceList.validator_prices":
		return len(x.ValidatorPrices) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPriceList"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPriceList does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ValidatorPriceList) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ValidatorPriceList.validator":
		x.Validator = ""
	case "band.feeds.v1beta1.ValidatorPriceList.validator_prices":
		x.ValidatorPrices = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPriceList"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPriceList does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_ValidatorPriceList) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.ValidatorPriceList.validator":
		value := x.Validator
		return protoreflect.ValueOfString(value)
	case "band.feeds.v1beta1.ValidatorPriceList.validator_prices":
		if len(x.ValidatorPrices) == 0 {
			return protoreflect.ValueOfList(&_ValidatorPriceList_2_list{})
		}
		listValue := &_ValidatorPriceList_2_list{list: &x.ValidatorPrices}
		return protoreflect.ValueOfList(listValue)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPriceList"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPriceList does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ValidatorPriceList) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ValidatorPriceList.validator":
		x.Validator = value.Interface().(string)
	case "band.feeds.v1beta1.ValidatorPriceList.validator_prices":
		lv := value.List()
		clv := lv.(*_ValidatorPriceList_2_list)
		x.ValidatorPrices = *clv.list
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPriceList"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPriceList does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ValidatorPriceList) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ValidatorPriceList.validator_prices":
		if x.ValidatorPrices == nil {
			x.ValidatorPrices = []*ValidatorPrice{}
		}
		value := &_ValidatorPriceList_2_list{list: &x.ValidatorPrices}
		return protoreflect.ValueOfList(value)
	case "band.feeds.v1beta1.ValidatorPriceList.validator":
		panic(fmt.Errorf("field validator of message band.feeds.v1beta1.ValidatorPriceList is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPriceList"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPriceList does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_ValidatorPriceList) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ValidatorPriceList.validator":
		return protoreflect.ValueOfString("")
	case "band.feeds.v1beta1.ValidatorPriceList.validator_prices":
		list := []*ValidatorPrice{}
		return protoreflect.ValueOfList(&_ValidatorPriceList_2_list{list: &list})
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ValidatorPriceList"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ValidatorPriceList does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_ValidatorPriceList) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.ValidatorPriceList", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_ValidatorPriceList) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ValidatorPriceList) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_ValidatorPriceList) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_ValidatorPriceList) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*ValidatorPriceList)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Validator)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.ValidatorPrices) > 0 {
			for _, e := range x.ValidatorPrices {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*ValidatorPriceList)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.ValidatorPrices) > 0 {
			for iNdEx := len(x.ValidatorPrices) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.ValidatorPrices[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x12
			}
		}
		if len(x.Validator) > 0 {
			i -= len(x.Validator)
			copy(dAtA[i:], x.Validator)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Validator)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*ValidatorPriceList)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorPriceList: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorPriceList: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Validator = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorPrices", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.ValidatorPrices = append(x.ValidatorPrices, &ValidatorPrice{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidatorPrices[len(x.ValidatorPrices)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_ReferenceSourceConfig                    protoreflect.MessageDescriptor
	fd_ReferenceSourceConfig_registry_ipfs_hash protoreflect.FieldDescriptor
	fd_ReferenceSourceConfig_registry_version   protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_ReferenceSourceConfig = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("ReferenceSourceConfig")
	fd_ReferenceSourceConfig_registry_ipfs_hash = md_ReferenceSourceConfig.Fields().ByName("registry_ipfs_hash")
	fd_ReferenceSourceConfig_registry_version = md_ReferenceSourceConfig.Fields().ByName("registry_version")
}

var _ protoreflect.Message = (*fastReflection_ReferenceSourceConfig)(nil)

type fastReflection_ReferenceSourceConfig ReferenceSourceConfig

func (x *ReferenceSourceConfig) ProtoReflect() protoreflect.Message {
	return (*fastReflection_ReferenceSourceConfig)(x)
}

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

var _fastReflection_ReferenceSourceConfig_messageType fastReflection_ReferenceSourceConfig_messageType
var _ protoreflect.MessageType = fastReflection_ReferenceSourceConfig_messageType{}

type fastReflection_ReferenceSourceConfig_messageType struct{}

func (x fastReflection_ReferenceSourceConfig_messageType) Zero() protoreflect.Message {
	return (*fastReflection_ReferenceSourceConfig)(nil)
}
func (x fastReflection_ReferenceSourceConfig_messageType) New() protoreflect.Message {
	return new(fastReflection_ReferenceSourceConfig)
}
func (x fastReflection_ReferenceSourceConfig_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_ReferenceSourceConfig
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_ReferenceSourceConfig) Descriptor() protoreflect.MessageDescriptor {
	return md_ReferenceSourceConfig
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_ReferenceSourceConfig) Type() protoreflect.MessageType {
	return _fastReflection_ReferenceSourceConfig_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_ReferenceSourceConfig) New() protoreflect.Message {
	return new(fastReflection_ReferenceSourceConfig)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_ReferenceSourceConfig) Interface() protoreflect.ProtoMessage {
	return (*ReferenceSourceConfig)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_ReferenceSourceConfig) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.RegistryIpfsHash != "" {
		value := protoreflect.ValueOfString(x.RegistryIpfsHash)
		if !f(fd_ReferenceSourceConfig_registry_ipfs_hash, value) {
			return
		}
	}
	if x.RegistryVersion != "" {
		value := protoreflect.ValueOfString(x.RegistryVersion)
		if !f(fd_ReferenceSourceConfig_registry_version, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_ReferenceSourceConfig) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_ipfs_hash":
		return x.RegistryIpfsHash != ""
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_version":
		return x.RegistryVersion != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ReferenceSourceConfig"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ReferenceSourceConfig does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ReferenceSourceConfig) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_ipfs_hash":
		x.RegistryIpfsHash = ""
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_version":
		x.RegistryVersion = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ReferenceSourceConfig"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ReferenceSourceConfig does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_ReferenceSourceConfig) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_ipfs_hash":
		value := x.RegistryIpfsHash
		return protoreflect.ValueOfString(value)
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_version":
		value := x.RegistryVersion
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ReferenceSourceConfig"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ReferenceSourceConfig does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ReferenceSourceConfig) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_ipfs_hash":
		x.RegistryIpfsHash = value.Interface().(string)
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_version":
		x.RegistryVersion = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ReferenceSourceConfig"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ReferenceSourceConfig does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ReferenceSourceConfig) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_ipfs_hash":
		panic(fmt.Errorf("field registry_ipfs_hash of message band.feeds.v1beta1.ReferenceSourceConfig is not mutable"))
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_version":
		panic(fmt.Errorf("field registry_version of message band.feeds.v1beta1.ReferenceSourceConfig is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ReferenceSourceConfig"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ReferenceSourceConfig does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_ReferenceSourceConfig) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_ipfs_hash":
		return protoreflect.ValueOfString("")
	case "band.feeds.v1beta1.ReferenceSourceConfig.registry_version":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.ReferenceSourceConfig"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.ReferenceSourceConfig does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_ReferenceSourceConfig) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.ReferenceSourceConfig", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_ReferenceSourceConfig) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_ReferenceSourceConfig) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_ReferenceSourceConfig) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_ReferenceSourceConfig) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*ReferenceSourceConfig)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.RegistryIpfsHash)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.RegistryVersion)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*ReferenceSourceConfig)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.RegistryVersion) > 0 {
			i -= len(x.RegistryVersion)
			copy(dAtA[i:], x.RegistryVersion)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RegistryVersion)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.RegistryIpfsHash) > 0 {
			i -= len(x.RegistryIpfsHash)
			copy(dAtA[i:], x.RegistryIpfsHash)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RegistryIpfsHash)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*ReferenceSourceConfig)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ReferenceSourceConfig: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ReferenceSourceConfig: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RegistryIpfsHash", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.RegistryIpfsHash = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RegistryVersion", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.RegistryVersion = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_FeedsSignatureOrder_1_list)(nil)

type _FeedsSignatureOrder_1_list struct {
	list *[]string
}

func (x *_FeedsSignatureOrder_1_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_FeedsSignatureOrder_1_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfString((*x.list)[i])
}

func (x *_FeedsSignatureOrder_1_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.String()
	concreteValue := valueUnwrapped
	(*x.list)[i] = concreteValue
}

func (x *_FeedsSignatureOrder_1_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.String()
	concreteValue := valueUnwrapped
	*x.list = append(*x.list, concreteValue)
}

func (x *_FeedsSignatureOrder_1_list) AppendMutable() protoreflect.Value {
	panic(fmt.Errorf("AppendMutable can not be called on message FeedsSignatureOrder at list field SignalIds as it is not of Message kind"))
}

func (x *_FeedsSignatureOrder_1_list) Truncate(n int) {
	*x.list = (*x.list)[:n]
}

func (x *_FeedsSignatureOrder_1_list) NewElement() protoreflect.Value {
	v := ""
	return protoreflect.ValueOfString(v)
}

func (x *_FeedsSignatureOrder_1_list) IsValid() bool {
	return x.list != nil
}

var (
	md_FeedsSignatureOrder            protoreflect.MessageDescriptor
	fd_FeedsSignatureOrder_signal_ids protoreflect.FieldDescriptor
	fd_FeedsSignatureOrder_encoder    protoreflect.FieldDescriptor
)

func init() {
	file_band_feeds_v1beta1_feeds_proto_init()
	md_FeedsSignatureOrder = File_band_feeds_v1beta1_feeds_proto.Messages().ByName("FeedsSignatureOrder")
	fd_FeedsSignatureOrder_signal_ids = md_FeedsSignatureOrder.Fields().ByName("signal_ids")
	fd_FeedsSignatureOrder_encoder = md_FeedsSignatureOrder.Fields().ByName("encoder")
}

var _ protoreflect.Message = (*fastReflection_FeedsSignatureOrder)(nil)

type fastReflection_FeedsSignatureOrder FeedsSignatureOrder

func (x *FeedsSignatureOrder) ProtoReflect() protoreflect.Message {
	return (*fastReflection_FeedsSignatureOrder)(x)
}

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

var _fastReflection_FeedsSignatureOrder_messageType fastReflection_FeedsSignatureOrder_messageType
var _ protoreflect.MessageType = fastReflection_FeedsSignatureOrder_messageType{}

type fastReflection_FeedsSignatureOrder_messageType struct{}

func (x fastReflection_FeedsSignatureOrder_messageType) Zero() protoreflect.Message {
	return (*fastReflection_FeedsSignatureOrder)(nil)
}
func (x fastReflection_FeedsSignatureOrder_messageType) New() protoreflect.Message {
	return new(fastReflection_FeedsSignatureOrder)
}
func (x fastReflection_FeedsSignatureOrder_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_FeedsSignatureOrder
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_FeedsSignatureOrder) Descriptor() protoreflect.MessageDescriptor {
	return md_FeedsSignatureOrder
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_FeedsSignatureOrder) Type() protoreflect.MessageType {
	return _fastReflection_FeedsSignatureOrder_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_FeedsSignatureOrder) New() protoreflect.Message {
	return new(fastReflection_FeedsSignatureOrder)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_FeedsSignatureOrder) Interface() protoreflect.ProtoMessage {
	return (*FeedsSignatureOrder)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_FeedsSignatureOrder) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if len(x.SignalIds) != 0 {
		value := protoreflect.ValueOfList(&_FeedsSignatureOrder_1_list{list: &x.SignalIds})
		if !f(fd_FeedsSignatureOrder_signal_ids, value) {
			return
		}
	}
	if x.Encoder != 0 {
		value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Encoder))
		if !f(fd_FeedsSignatureOrder_encoder, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_FeedsSignatureOrder) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "band.feeds.v1beta1.FeedsSignatureOrder.signal_ids":
		return len(x.SignalIds) != 0
	case "band.feeds.v1beta1.FeedsSignatureOrder.encoder":
		return x.Encoder != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedsSignatureOrder"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedsSignatureOrder does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_FeedsSignatureOrder) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.FeedsSignatureOrder.signal_ids":
		x.SignalIds = nil
	case "band.feeds.v1beta1.FeedsSignatureOrder.encoder":
		x.Encoder = 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedsSignatureOrder"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedsSignatureOrder does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_FeedsSignatureOrder) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "band.feeds.v1beta1.FeedsSignatureOrder.signal_ids":
		if len(x.SignalIds) == 0 {
			return protoreflect.ValueOfList(&_FeedsSignatureOrder_1_list{})
		}
		listValue := &_FeedsSignatureOrder_1_list{list: &x.SignalIds}
		return protoreflect.ValueOfList(listValue)
	case "band.feeds.v1beta1.FeedsSignatureOrder.encoder":
		value := x.Encoder
		return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedsSignatureOrder"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedsSignatureOrder does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_FeedsSignatureOrder) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "band.feeds.v1beta1.FeedsSignatureOrder.signal_ids":
		lv := value.List()
		clv := lv.(*_FeedsSignatureOrder_1_list)
		x.SignalIds = *clv.list
	case "band.feeds.v1beta1.FeedsSignatureOrder.encoder":
		x.Encoder = (Encoder)(value.Enum())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedsSignatureOrder"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedsSignatureOrder does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_FeedsSignatureOrder) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.FeedsSignatureOrder.signal_ids":
		if x.SignalIds == nil {
			x.SignalIds = []string{}
		}
		value := &_FeedsSignatureOrder_1_list{list: &x.SignalIds}
		return protoreflect.ValueOfList(value)
	case "band.feeds.v1beta1.FeedsSignatureOrder.encoder":
		panic(fmt.Errorf("field encoder of message band.feeds.v1beta1.FeedsSignatureOrder is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedsSignatureOrder"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedsSignatureOrder does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_FeedsSignatureOrder) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "band.feeds.v1beta1.FeedsSignatureOrder.signal_ids":
		list := []string{}
		return protoreflect.ValueOfList(&_FeedsSignatureOrder_1_list{list: &list})
	case "band.feeds.v1beta1.FeedsSignatureOrder.encoder":
		return protoreflect.ValueOfEnum(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: band.feeds.v1beta1.FeedsSignatureOrder"))
		}
		panic(fmt.Errorf("message band.feeds.v1beta1.FeedsSignatureOrder does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_FeedsSignatureOrder) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in band.feeds.v1beta1.FeedsSignatureOrder", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_FeedsSignatureOrder) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_FeedsSignatureOrder) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_FeedsSignatureOrder) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_FeedsSignatureOrder) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*FeedsSignatureOrder)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if len(x.SignalIds) > 0 {
			for _, s := range x.SignalIds {
				l = len(s)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.Encoder != 0 {
			n += 1 + runtime.Sov(uint64(x.Encoder))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*FeedsSignatureOrder)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Encoder != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Encoder))
			i--
			dAtA[i] = 0x10
		}
		if len(x.SignalIds) > 0 {
			for iNdEx := len(x.SignalIds) - 1; iNdEx >= 0; iNdEx-- {
				i -= len(x.SignalIds[iNdEx])
				copy(dAtA[i:], x.SignalIds[iNdEx])
				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SignalIds[iNdEx])))
				i--
				dAtA[i] = 0xa
			}
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*FeedsSignatureOrder)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: FeedsSignatureOrder: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: FeedsSignatureOrder: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SignalIds", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.SignalIds = append(x.SignalIds, string(dAtA[iNdEx:postIndex]))
				iNdEx = postIndex
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Encoder", wireType)
				}
				x.Encoder = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Encoder |= Encoder(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.27.0
// 	protoc        (unknown)
// source: band/feeds/v1beta1/feeds.proto

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

// PriceStatus is a structure that defines the price status of a price.
type PriceStatus int32

const (
	// PRICE_STATUS_UNSPECIFIED is an unspecified price status.
	PriceStatus_PRICE_STATUS_UNSPECIFIED PriceStatus = 0
	// PRICE_STATUS_UNKNOWN_SIGNAL_ID is an unknown signal id price status.
	PriceStatus_PRICE_STATUS_UNKNOWN_SIGNAL_ID PriceStatus = 1
	// PRICE_STATUS_NOT_READY is a not ready price status.
	PriceStatus_PRICE_STATUS_NOT_READY PriceStatus = 2
	// PRICE_STATUS_AVAILABLE is an available price status.
	PriceStatus_PRICE_STATUS_AVAILABLE PriceStatus = 3
	// PRICE_STATUS_NOT_IN_CURRENT_FEEDS is a not in current feed price status.
	PriceStatus_PRICE_STATUS_NOT_IN_CURRENT_FEEDS PriceStatus = 4
)

// Enum value maps for PriceStatus.
var (
	PriceStatus_name = map[int32]string{
		0: "PRICE_STATUS_UNSPECIFIED",
		1: "PRICE_STATUS_UNKNOWN_SIGNAL_ID",
		2: "PRICE_STATUS_NOT_READY",
		3: "PRICE_STATUS_AVAILABLE",
		4: "PRICE_STATUS_NOT_IN_CURRENT_FEEDS",
	}
	PriceStatus_value = map[string]int32{
		"PRICE_STATUS_UNSPECIFIED":          0,
		"PRICE_STATUS_UNKNOWN_SIGNAL_ID":    1,
		"PRICE_STATUS_NOT_READY":            2,
		"PRICE_STATUS_AVAILABLE":            3,
		"PRICE_STATUS_NOT_IN_CURRENT_FEEDS": 4,
	}
)

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

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

func (PriceStatus) Descriptor() protoreflect.EnumDescriptor {
	return file_band_feeds_v1beta1_feeds_proto_enumTypes[0].Descriptor()
}

func (PriceStatus) Type() protoreflect.EnumType {
	return &file_band_feeds_v1beta1_feeds_proto_enumTypes[0]
}

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

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

// SignalPriceStatus is a structure that defines the price status of a signal id.
type SignalPriceStatus int32

const (
	// SIGNAL_PRICE_STATUS_UNSPECIFIED is an unspecified signal price status.
	SignalPriceStatus_SIGNAL_PRICE_STATUS_UNSPECIFIED SignalPriceStatus = 0
	// SIGNAL_PRICE_STATUS_UNSUPPORTED is an unsupported signal price status.
	SignalPriceStatus_SIGNAL_PRICE_STATUS_UNSUPPORTED SignalPriceStatus = 1
	// SIGNAL_PRICE_STATUS_UNAVAILABLE is an unavailable signal price status.
	SignalPriceStatus_SIGNAL_PRICE_STATUS_UNAVAILABLE SignalPriceStatus = 2
	// SIGNAL_PRICE_STATUS_AVAILABLE is an available signal price status.
	SignalPriceStatus_SIGNAL_PRICE_STATUS_AVAILABLE SignalPriceStatus = 3
)

// Enum value maps for SignalPriceStatus.
var (
	SignalPriceStatus_name = map[int32]string{
		0: "SIGNAL_PRICE_STATUS_UNSPECIFIED",
		1: "SIGNAL_PRICE_STATUS_UNSUPPORTED",
		2: "SIGNAL_PRICE_STATUS_UNAVAILABLE",
		3: "SIGNAL_PRICE_STATUS_AVAILABLE",
	}
	SignalPriceStatus_value = map[string]int32{
		"SIGNAL_PRICE_STATUS_UNSPECIFIED": 0,
		"SIGNAL_PRICE_STATUS_UNSUPPORTED": 1,
		"SIGNAL_PRICE_STATUS_UNAVAILABLE": 2,
		"SIGNAL_PRICE_STATUS_AVAILABLE":   3,
	}
)

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

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

func (SignalPriceStatus) Descriptor() protoreflect.EnumDescriptor {
	return file_band_feeds_v1beta1_feeds_proto_enumTypes[1].Descriptor()
}

func (SignalPriceStatus) Type() protoreflect.EnumType {
	return &file_band_feeds_v1beta1_feeds_proto_enumTypes[1]
}

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

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

// Signal is the data structure that contains signal id and power of that signal.
type Signal struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// id is the id of the signal.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// power is the power of the corresponding signal id.
	Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"`
}

func (x *Signal) Reset() {
	*x = Signal{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Signal) ProtoMessage() {}

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

func (x *Signal) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *Signal) GetPower() int64 {
	if x != nil {
		return x.Power
	}
	return 0
}

// Vote is the data structure that contains array of signals of a voter.
type Vote struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// voter is the address of the voter of this signals.
	Voter string `protobuf:"bytes,1,opt,name=voter,proto3" json:"voter,omitempty"`
	// signals is a list of signals submit by the voter.
	Signals []*Signal `protobuf:"bytes,2,rep,name=signals,proto3" json:"signals,omitempty"`
}

func (x *Vote) Reset() {
	*x = Vote{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Vote) ProtoMessage() {}

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

func (x *Vote) GetVoter() string {
	if x != nil {
		return x.Voter
	}
	return ""
}

func (x *Vote) GetSignals() []*Signal {
	if x != nil {
		return x.Signals
	}
	return nil
}

// Feed is a structure that holds a signal id, its total power, and its calculated interval.
type Feed struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// signal_id is the unique string that identifies the unit of feed.
	SignalId string `protobuf:"bytes,1,opt,name=signal_id,json=signalId,proto3" json:"signal_id,omitempty"`
	// power is the power of the corresponding signal id.
	Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"`
	// interval is the interval of the price feed.
	Interval int64 `protobuf:"varint,3,opt,name=interval,proto3" json:"interval,omitempty"`
}

func (x *Feed) Reset() {
	*x = Feed{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Feed) ProtoMessage() {}

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

func (x *Feed) GetSignalId() string {
	if x != nil {
		return x.SignalId
	}
	return ""
}

func (x *Feed) GetPower() int64 {
	if x != nil {
		return x.Power
	}
	return 0
}

func (x *Feed) GetInterval() int64 {
	if x != nil {
		return x.Interval
	}
	return 0
}

// FeedWithDeviation is a structure that holds a signal id, its total power, and its calculated interval and deviation.
type FeedWithDeviation struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// signal_id is the unique string that identifies the unit of feed.
	SignalId string `protobuf:"bytes,1,opt,name=signal_id,json=signalId,proto3" json:"signal_id,omitempty"`
	// power is the power of the corresponding signal id.
	Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"`
	// interval is the interval of the price feed.
	Interval int64 `protobuf:"varint,3,opt,name=interval,proto3" json:"interval,omitempty"`
	// deviation_basis_point is the maximum deviation value the feed can tolerate, expressed in basis points.
	DeviationBasisPoint int64 `protobuf:"varint,4,opt,name=deviation_basis_point,json=deviationBasisPoint,proto3" json:"deviation_basis_point,omitempty"`
}

func (x *FeedWithDeviation) Reset() {
	*x = FeedWithDeviation{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*FeedWithDeviation) ProtoMessage() {}

// Deprecated: Use FeedWithDeviation.ProtoReflect.Descriptor instead.
func (*FeedWithDeviation) Descriptor() ([]byte, []int) {
	return file_band_feeds_v1beta1_feeds_proto_rawDescGZIP(), []int{3}
}

func (x *FeedWithDeviation) GetSignalId() string {
	if x != nil {
		return x.SignalId
	}
	return ""
}

func (x *FeedWithDeviation) GetPower() int64 {
	if x != nil {
		return x.Power
	}
	return 0
}

func (x *FeedWithDeviation) GetInterval() int64 {
	if x != nil {
		return x.Interval
	}
	return 0
}

func (x *FeedWithDeviation) GetDeviationBasisPoint() int64 {
	if x != nil {
		return x.DeviationBasisPoint
	}
	return 0
}

// CurrentFeeds is a structure that holds a list of currently supported feeds, and its last update time and block.
type CurrentFeeds struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// feeds is a list of currently supported feeds.
	Feeds []*Feed `protobuf:"bytes,1,rep,name=feeds,proto3" json:"feeds,omitempty"`
	// last_update_timestamp is the timestamp of the last time supported feeds list is updated.
	LastUpdateTimestamp int64 `protobuf:"varint,2,opt,name=last_update_timestamp,json=lastUpdateTimestamp,proto3" json:"last_update_timestamp,omitempty"`
	// last_update_block is the number of blocks of the last time supported feeds list is updated.
	LastUpdateBlock int64 `protobuf:"varint,3,opt,name=last_update_block,json=lastUpdateBlock,proto3" json:"last_update_block,omitempty"`
}

func (x *CurrentFeeds) Reset() {
	*x = CurrentFeeds{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[4]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CurrentFeeds) ProtoMessage() {}

// Deprecated: Use CurrentFeeds.ProtoReflect.Descriptor instead.
func (*CurrentFeeds) Descriptor() ([]byte, []int) {
	return file_band_feeds_v1beta1_feeds_proto_rawDescGZIP(), []int{4}
}

func (x *CurrentFeeds) GetFeeds() []*Feed {
	if x != nil {
		return x.Feeds
	}
	return nil
}

func (x *CurrentFeeds) GetLastUpdateTimestamp() int64 {
	if x != nil {
		return x.LastUpdateTimestamp
	}
	return 0
}

func (x *CurrentFeeds) GetLastUpdateBlock() int64 {
	if x != nil {
		return x.LastUpdateBlock
	}
	return 0
}

// CurrentFeedWithDeviations is a structure that holds a list of currently supported feed-with-deviations, and its
// last update time and block.
type CurrentFeedWithDeviations struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// feeds is a list of currently supported feed-with-deviations.
	Feeds []*FeedWithDeviation `protobuf:"bytes,1,rep,name=feeds,proto3" json:"feeds,omitempty"`
	// last_update_timestamp is the timestamp of the last time supported feeds list is updated.
	LastUpdateTimestamp int64 `protobuf:"varint,2,opt,name=last_update_timestamp,json=lastUpdateTimestamp,proto3" json:"last_update_timestamp,omitempty"`
	// last_update_block is the number of blocks of the last time supported feeds list is updated.
	LastUpdateBlock int64 `protobuf:"varint,3,opt,name=last_update_block,json=lastUpdateBlock,proto3" json:"last_update_block,omitempty"`
}

func (x *CurrentFeedWithDeviations) Reset() {
	*x = CurrentFeedWithDeviations{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[5]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CurrentFeedWithDeviations) ProtoMessage() {}

// Deprecated: Use CurrentFeedWithDeviations.ProtoReflect.Descriptor instead.
func (*CurrentFeedWithDeviations) Descriptor() ([]byte, []int) {
	return file_band_feeds_v1beta1_feeds_proto_rawDescGZIP(), []int{5}
}

func (x *CurrentFeedWithDeviations) GetFeeds() []*FeedWithDeviation {
	if x != nil {
		return x.Feeds
	}
	return nil
}

func (x *CurrentFeedWithDeviations) GetLastUpdateTimestamp() int64 {
	if x != nil {
		return x.LastUpdateTimestamp
	}
	return 0
}

func (x *CurrentFeedWithDeviations) GetLastUpdateBlock() int64 {
	if x != nil {
		return x.LastUpdateBlock
	}
	return 0
}

// Price is a structure that defines the price of a signal id.
type Price struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// status is the status of a the price.
	Status PriceStatus `protobuf:"varint,1,opt,name=status,proto3,enum=band.feeds.v1beta1.PriceStatus" json:"status,omitempty"`
	// signal_id is the signal id of the price.
	SignalId string `protobuf:"bytes,2,opt,name=signal_id,json=signalId,proto3" json:"signal_id,omitempty"`
	// price is the price of the signal id.
	Price uint64 `protobuf:"varint,3,opt,name=price,proto3" json:"price,omitempty"`
	// timestamp is the timestamp at which the price was aggregated.
	Timestamp int64 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
}

func (x *Price) Reset() {
	*x = Price{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[6]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Price) ProtoMessage() {}

// Deprecated: Use Price.ProtoReflect.Descriptor instead.
func (*Price) Descriptor() ([]byte, []int) {
	return file_band_feeds_v1beta1_feeds_proto_rawDescGZIP(), []int{6}
}

func (x *Price) GetStatus() PriceStatus {
	if x != nil {
		return x.Status
	}
	return PriceStatus_PRICE_STATUS_UNSPECIFIED
}

func (x *Price) GetSignalId() string {
	if x != nil {
		return x.SignalId
	}
	return ""
}

func (x *Price) GetPrice() uint64 {
	if x != nil {
		return x.Price
	}
	return 0
}

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

// SignalPrice is a structure that defines the signaled price of a signal id.
type SignalPrice struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// status is the status of the signal price.
	Status SignalPriceStatus `protobuf:"varint,1,opt,name=status,proto3,enum=band.feeds.v1beta1.SignalPriceStatus" json:"status,omitempty"`
	// signal_id is the signal id of the price.
	SignalId string `protobuf:"bytes,2,opt,name=signal_id,json=signalId,proto3" json:"signal_id,omitempty"`
	// price is the price submitted by the validator.
	Price uint64 `protobuf:"varint,3,opt,name=price,proto3" json:"price,omitempty"`
}

func (x *SignalPrice) Reset() {
	*x = SignalPrice{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[7]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*SignalPrice) ProtoMessage() {}

// Deprecated: Use SignalPrice.ProtoReflect.Descriptor instead.
func (*SignalPrice) Descriptor() ([]byte, []int) {
	return file_band_feeds_v1beta1_feeds_proto_rawDescGZIP(), []int{7}
}

func (x *SignalPrice) GetStatus() SignalPriceStatus {
	if x != nil {
		return x.Status
	}
	return SignalPriceStatus_SIGNAL_PRICE_STATUS_UNSPECIFIED
}

func (x *SignalPrice) GetSignalId() string {
	if x != nil {
		return x.SignalId
	}
	return ""
}

func (x *SignalPrice) GetPrice() uint64 {
	if x != nil {
		return x.Price
	}
	return 0
}

// ValidatorPrice is a structure that defines the price submitted by a validator for a signal id.
type ValidatorPrice struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// signal_price_status is the status of a signal price submitted.
	SignalPriceStatus SignalPriceStatus `protobuf:"varint,1,opt,name=signal_price_status,json=signalPriceStatus,proto3,enum=band.feeds.v1beta1.SignalPriceStatus" json:"signal_price_status,omitempty"`
	// signal_id is the signal id of the price.
	SignalId string `protobuf:"bytes,2,opt,name=signal_id,json=signalId,proto3" json:"signal_id,omitempty"`
	// price is the price submitted by the validator.
	Price uint64 `protobuf:"varint,3,opt,name=price,proto3" json:"price,omitempty"`
	// timestamp is the timestamp at which the price was submitted.
	Timestamp int64 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// block_height is the block height at which the price was submitted.
	BlockHeight int64 `protobuf:"varint,5,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
}

func (x *ValidatorPrice) Reset() {
	*x = ValidatorPrice{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[8]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*ValidatorPrice) ProtoMessage() {}

// Deprecated: Use ValidatorPrice.ProtoReflect.Descriptor instead.
func (*ValidatorPrice) Descriptor() ([]byte, []int) {
	return file_band_feeds_v1beta1_feeds_proto_rawDescGZIP(), []int{8}
}

func (x *ValidatorPrice) GetSignalPriceStatus() SignalPriceStatus {
	if x != nil {
		return x.SignalPriceStatus
	}
	return SignalPriceStatus_SIGNAL_PRICE_STATUS_UNSPECIFIED
}

func (x *ValidatorPrice) GetSignalId() string {
	if x != nil {
		return x.SignalId
	}
	return ""
}

func (x *ValidatorPrice) GetPrice() uint64 {
	if x != nil {
		return x.Price
	}
	return 0
}

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

func (x *ValidatorPrice) GetBlockHeight() int64 {
	if x != nil {
		return x.BlockHeight
	}
	return 0
}

// ValidatorPriceList is a structure that holds a list of validator prices of
// a validator and its address.
type ValidatorPriceList struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// validator is the validator address.
	Validator string `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator,omitempty"`
	// validators_prices is a list of validator prices.
	ValidatorPrices []*ValidatorPrice `protobuf:"bytes,2,rep,name=validator_prices,json=validatorPrices,proto3" json:"validator_prices,omitempty"`
}

func (x *ValidatorPriceList) Reset() {
	*x = ValidatorPriceList{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[9]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*ValidatorPriceList) ProtoMessage() {}

// Deprecated: Use ValidatorPriceList.ProtoReflect.Descriptor instead.
func (*ValidatorPriceList) Descriptor() ([]byte, []int) {
	return file_band_feeds_v1beta1_feeds_proto_rawDescGZIP(), []int{9}
}

func (x *ValidatorPriceList) GetValidator() string {
	if x != nil {
		return x.Validator
	}
	return ""
}

func (x *ValidatorPriceList) GetValidatorPrices() []*ValidatorPrice {
	if x != nil {
		return x.ValidatorPrices
	}
	return nil
}

// ReferenceSourceConfig is a structure that defines the information of reference price source.
type ReferenceSourceConfig struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// registry_ipfs_hash is the hash of the reference registry.
	RegistryIpfsHash string `protobuf:"bytes,1,opt,name=registry_ipfs_hash,json=registryIpfsHash,proto3" json:"registry_ipfs_hash,omitempty"`
	// registry_version is the version of the reference registry.
	RegistryVersion string `protobuf:"bytes,2,opt,name=registry_version,json=registryVersion,proto3" json:"registry_version,omitempty"`
}

func (x *ReferenceSourceConfig) Reset() {
	*x = ReferenceSourceConfig{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[10]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*ReferenceSourceConfig) ProtoMessage() {}

// Deprecated: Use ReferenceSourceConfig.ProtoReflect.Descriptor instead.
func (*ReferenceSourceConfig) Descriptor() ([]byte, []int) {
	return file_band_feeds_v1beta1_feeds_proto_rawDescGZIP(), []int{10}
}

func (x *ReferenceSourceConfig) GetRegistryIpfsHash() string {
	if x != nil {
		return x.RegistryIpfsHash
	}
	return ""
}

func (x *ReferenceSourceConfig) GetRegistryVersion() string {
	if x != nil {
		return x.RegistryVersion
	}
	return ""
}

// FeedsSignatureOrder defines a general signature order for feed data.
type FeedsSignatureOrder struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// signal_ids is the list of signal ids that require signatures.
	SignalIds []string `protobuf:"bytes,1,rep,name=signal_ids,json=signalIds,proto3" json:"signal_ids,omitempty"`
	// encoder is the mode of encoding feeds signature order.
	Encoder Encoder `protobuf:"varint,2,opt,name=encoder,proto3,enum=band.feeds.v1beta1.Encoder" json:"encoder,omitempty"`
}

func (x *FeedsSignatureOrder) Reset() {
	*x = FeedsSignatureOrder{}
	if protoimpl.UnsafeEnabled {
		mi := &file_band_feeds_v1beta1_feeds_proto_msgTypes[11]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*FeedsSignatureOrder) ProtoMessage() {}

// Deprecated: Use FeedsSignatureOrder.ProtoReflect.Descriptor instead.
func (*FeedsSignatureOrder) Descriptor() ([]byte, []int) {
	return file_band_feeds_v1beta1_feeds_proto_rawDescGZIP(), []int{11}
}

func (x *FeedsSignatureOrder) GetSignalIds() []string {
	if x != nil {
		return x.SignalIds
	}
	return nil
}

func (x *FeedsSignatureOrder) GetEncoder() Encoder {
	if x != nil {
		return x.Encoder
	}
	return Encoder_ENCODER_UNSPECIFIED
}

var File_band_feeds_v1beta1_feeds_proto protoreflect.FileDescriptor

var file_band_feeds_v1beta1_feeds_proto_rawDesc = []byte{
	0x0a, 0x1e, 0x62, 0x61, 0x6e, 0x64, 0x2f, 0x66, 0x65, 0x65, 0x64, 0x73, 0x2f, 0x76, 0x31, 0x62,
	0x65, 0x74, 0x61, 0x31, 0x2f, 0x66, 0x65, 0x65, 0x64, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
	0x12, 0x12, 0x62, 0x61, 0x6e, 0x64, 0x2e, 0x66, 0x65, 0x65, 0x64, 0x73, 0x2e, 0x76, 0x31, 0x62,
	0x65, 0x74, 0x61, 0x31, 0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
	0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x62, 0x61, 0x6e, 0x64, 0x2f, 0x66, 0x65, 0x65, 0x64,
	0x73, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65,
	0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x3c, 0x0a, 0x06, 0x53, 0x69, 0x67, 0x6e, 0x61,
	0x6c, 0x12, 0x16, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x06, 0xe2,
	0xde, 0x1f, 0x02, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x6f, 0x77,
	0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x3a,
	0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x78, 0x0a, 0x04, 0x56, 0x6f, 0x74, 0x65, 0x12, 0x2e, 0x0a,
	0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4,
	0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x12, 0x3a, 0x0a,
	0x07, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a,
	0x2e, 0x62, 0x61, 0x6e, 0x64, 0x2e, 0x66, 0x65, 0x65, 0x64, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65,
	0x74, 0x61, 0x31, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00,
	0x52, 0x07, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22,
	0x69, 0x0a, 0x04, 0x46, 0x65, 0x65, 0x64, 0x12, 0x29, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61,
	0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0c, 0xe2, 0xde, 0x1f, 0x08,
	0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49, 0x44, 0x52, 0x08, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c,
	0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28,
	0x03, 0x52, 0x05, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65,
	0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65,
	0x72, 0x76, 0x61, 0x6c, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xaa, 0x01, 0x0a, 0x11, 0x46,
	0x65, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e,
	0x12, 0x29, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20,
	0x01, 0x28, 0x09, 0x42, 0x0c, 0xe2, 0xde, 0x1f, 0x08, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49,
	0x44, 0x52, 0x08, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x70,
	0x6f, 0x77, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x70, 0x6f, 0x77, 0x65,
	0x72, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20,
	0x01, 0x28, 0x03, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x32, 0x0a,
	0x15, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x61, 0x73, 0x69, 0x73,
	0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x64, 0x65,
	0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x61, 0x73, 0x69, 0x73, 0x50, 0x6f, 0x69, 0x6e,
	0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xaa, 0x01, 0x0a, 0x0c, 0x43, 0x75, 0x72, 0x72,
	0x65, 0x6e, 0x74, 0x46, 0x65, 0x65, 0x64, 0x73, 0x12, 0x34, 0x0a, 0x05, 0x66, 0x65, 0x65, 0x64,
	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x62, 0x61, 0x6e, 0x64, 0x2e, 0x66,
	0x65, 0x65, 0x64, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x46, 0x65, 0x65,
	0x64, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x05, 0x66, 0x65, 0x65, 0x64, 0x73, 0x12, 0x32,
	0x0a, 0x15, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x69,
	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x6c,
	0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
	0x6d, 0x70, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74,
	0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x6c,
	0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x3a, 0x04,
	0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xc4, 0x01, 0x0a, 0x19, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
	0x46, 0x65, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f,
	0x6e, 0x73, 0x12, 0x41, 0x0a, 0x05, 0x66, 0x65, 0x65, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
	0x0b, 0x32, 0x25, 0x2e, 0x62, 0x61, 0x6e, 0x64, 0x2e, 0x66, 0x65, 0x65, 0x64, 0x73, 0x2e, 0x76,
	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x46, 0x65, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x44,
	0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x05,
	0x66, 0x65, 0x65, 0x64, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70,
	0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02,
	0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
	0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x61, 0x73,
	0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x03,
	0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
	0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xa5, 0x01, 0x0a, 0x05,
	0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x37, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x62, 0x61, 0x6e, 0x64, 0x2e, 0x66, 0x65, 0x65,
	0x64, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x69, 0x63, 0x65,
	0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x29,
	0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
	0x09, 0x42, 0x0c, 0xe2, 0xde, 0x1f, 0x08, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49, 0x44, 0x52,
	0x08, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69,
	0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x12,
	0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01,
	0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x3a, 0x04, 0xe8,
	0xa0, 0x1f, 0x01, 0x22, 0x93, 0x01, 0x0a, 0x0b, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x50, 0x72,
	0x69, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20,
	0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x61, 0x6e, 0x64, 0x2e, 0x66, 0x65, 0x65, 0x64, 0x73,
	0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x50,
	0x72, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74,
	0x75, 0x73, 0x12, 0x29, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18,
	0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0c, 0xe2, 0xde, 0x1f, 0x08, 0x53, 0x69, 0x67, 0x6e, 0x61,
	0x6c, 0x49, 0x44, 0x52, 0x08, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x14, 0x0a,
	0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x70, 0x72,
	0x69, 0x63, 0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xef, 0x01, 0x0a, 0x0e, 0x56, 0x61,
	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x55, 0x0a, 0x13,
	0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x73, 0x74, 0x61,
	0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x61, 0x6e, 0x64,
	0x2e, 0x66, 0x65, 0x65, 0x64, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53,
	0x69, 0x67, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
	0x52, 0x11, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61,
	0x74, 0x75, 0x73, 0x12, 0x29, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x64,
	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0c, 0xe2, 0xde, 0x1f, 0x08, 0x53, 0x69, 0x67, 0x6e,
	0x61, 0x6c, 0x49, 0x44, 0x52, 0x08, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x14,
	0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x70,
	0x72, 0x69, 0x63, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
	0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
	0x6d, 0x70, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67,
	0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48,
	0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xb0, 0x01, 0x0a, 0x12,
	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x69, 0x63, 0x65, 0x4c, 0x69,
	0x73, 0x74, 0x12, 0x3f, 0x0a, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
	0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65,
	0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
	0x74, 0x6f, 0x72, 0x12, 0x53, 0x0a, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
	0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e,
	0x62, 0x61, 0x6e, 0x64, 0x2e, 0x66, 0x65, 0x65, 0x64, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
	0x61, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x69, 0x63,
	0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
	0x6f, 0x72, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x8c,
	0x01, 0x0a, 0x15, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x53, 0x6f, 0x75, 0x72,
	0x63, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x42, 0x0a, 0x12, 0x72, 0x65, 0x67, 0x69,
	0x73, 0x74, 0x72, 0x79, 0x5f, 0x69, 0x70, 0x66, 0x73, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01,
	0x20, 0x01, 0x28, 0x09, 0x42, 0x14, 0xe2, 0xde, 0x1f, 0x10, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
	0x72, 0x79, 0x49, 0x50, 0x46, 0x53, 0x48, 0x61, 0x73, 0x68, 0x52, 0x10, 0x72, 0x65, 0x67, 0x69,
	0x73, 0x74, 0x72, 0x79, 0x49, 0x70, 0x66, 0x73, 0x48, 0x61, 0x73, 0x68, 0x12, 0x29, 0x0a, 0x10,
	0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79,
	0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x80, 0x01,
	0x0a, 0x13, 0x46, 0x65, 0x65, 0x64, 0x73, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
	0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x2c, 0x0a, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x5f,
	0x69, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x42, 0x0d, 0xe2, 0xde, 0x1f, 0x09, 0x53,
	0x69, 0x67, 0x6e, 0x61, 0x6c, 0x49, 0x44, 0x73, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c,
	0x49, 0x64, 0x73, 0x12, 0x35, 0x0a, 0x07, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x72, 0x18, 0x02,
	0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x62, 0x61, 0x6e, 0x64, 0x2e, 0x66, 0x65, 0x65, 0x64,
	0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65,
	0x72, 0x52, 0x07, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x72, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00,
	0x2a, 0xb4, 0x01, 0x0a, 0x0b, 0x50, 0x72, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
	0x12, 0x1c, 0x0a, 0x18, 0x50, 0x52, 0x49, 0x43, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53,
	0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x22,
	0x0a, 0x1e, 0x50, 0x52, 0x49, 0x43, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55,
	0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x53, 0x49, 0x47, 0x4e, 0x41, 0x4c, 0x5f, 0x49, 0x44,
	0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x50, 0x52, 0x49, 0x43, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54,
	0x55, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x52, 0x45, 0x41, 0x44, 0x59, 0x10, 0x02, 0x12, 0x1a,
	0x0a, 0x16, 0x50, 0x52, 0x49, 0x43, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x41,
	0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x03, 0x12, 0x25, 0x0a, 0x21, 0x50, 0x52,
	0x49, 0x43, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x49,
	0x4e, 0x5f, 0x43, 0x55, 0x52, 0x52, 0x45, 0x4e, 0x54, 0x5f, 0x46, 0x45, 0x45, 0x44, 0x53, 0x10,
	0x04, 0x1a, 0x04, 0x88, 0xa3, 0x1e, 0x00, 0x2a, 0xab, 0x01, 0x0a, 0x11, 0x53, 0x69, 0x67, 0x6e,
	0x61, 0x6c, 0x50, 0x72, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x23, 0x0a,
	0x1f, 0x53, 0x49, 0x47, 0x4e, 0x41, 0x4c, 0x5f, 0x50, 0x52, 0x49, 0x43, 0x45, 0x5f, 0x53, 0x54,
	0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44,
	0x10, 0x00, 0x12, 0x23, 0x0a, 0x1f, 0x53, 0x49, 0x47, 0x4e, 0x41, 0x4c, 0x5f, 0x50, 0x52, 0x49,
	0x43, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x55, 0x50, 0x50,
	0x4f, 0x52, 0x54, 0x45, 0x44, 0x10, 0x01, 0x12, 0x23, 0x0a, 0x1f, 0x53, 0x49, 0x47, 0x4e, 0x41,
	0x4c, 0x5f, 0x50, 0x52, 0x49, 0x43, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55,
	0x4e, 0x41, 0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x02, 0x12, 0x21, 0x0a, 0x1d,
	0x53, 0x49, 0x47, 0x4e, 0x41, 0x4c, 0x5f, 0x50, 0x52, 0x49, 0x43, 0x45, 0x5f, 0x53, 0x54, 0x41,
	0x54, 0x55, 0x53, 0x5f, 0x41, 0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x03, 0x1a,
	0x04, 0x88, 0xa3, 0x1e, 0x00, 0x42, 0xd4, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x62, 0x61,
	0x6e, 0x64, 0x2e, 0x66, 0x65, 0x65, 0x64, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
	0x42, 0x0a, 0x46, 0x65, 0x65, 0x64, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x44,
	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x61, 0x6e, 0x64, 0x70,
	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2f, 0x76, 0x33,
	0x2f, 0x61, 0x70, 0x69, 0x2f, 0x62, 0x61, 0x6e, 0x64, 0x2f, 0x66, 0x65, 0x65, 0x64, 0x73, 0x2f,
	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x66, 0x65, 0x65, 0x64, 0x73, 0x76, 0x31, 0x62,
	0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x42, 0x46, 0x58, 0xaa, 0x02, 0x12, 0x42, 0x61, 0x6e,
	0x64, 0x2e, 0x46, 0x65, 0x65, 0x64, 0x73, 0x2e, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca,
	0x02, 0x12, 0x42, 0x61, 0x6e, 0x64, 0x5c, 0x46, 0x65, 0x65, 0x64, 0x73, 0x5c, 0x56, 0x31, 0x62,
	0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x1e, 0x42, 0x61, 0x6e, 0x64, 0x5c, 0x46, 0x65, 0x65, 0x64,
	0x73, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74,
	0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x42, 0x61, 0x6e, 0x64, 0x3a, 0x3a, 0x46, 0x65,
	0x65, 0x64, 0x73, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72,
	0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_band_feeds_v1beta1_feeds_proto_rawDescOnce sync.Once
	file_band_feeds_v1beta1_feeds_proto_rawDescData = file_band_feeds_v1beta1_feeds_proto_rawDesc
)

func file_band_feeds_v1beta1_feeds_proto_rawDescGZIP() []byte {
	file_band_feeds_v1beta1_feeds_proto_rawDescOnce.Do(func() {
		file_band_feeds_v1beta1_feeds_proto_rawDescData = protoimpl.X.CompressGZIP(file_band_feeds_v1beta1_feeds_proto_rawDescData)
	})
	return file_band_feeds_v1beta1_feeds_proto_rawDescData
}

var file_band_feeds_v1beta1_feeds_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_band_feeds_v1beta1_feeds_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
var file_band_feeds_v1beta1_feeds_proto_goTypes = []interface{}{
	(PriceStatus)(0),                  // 0: band.feeds.v1beta1.PriceStatus
	(SignalPriceStatus)(0),            // 1: band.feeds.v1beta1.SignalPriceStatus
	(*Signal)(nil),                    // 2: band.feeds.v1beta1.Signal
	(*Vote)(nil),                      // 3: band.feeds.v1beta1.Vote
	(*Feed)(nil),                      // 4: band.feeds.v1beta1.Feed
	(*FeedWithDeviation)(nil),         // 5: band.feeds.v1beta1.FeedWithDeviation
	(*CurrentFeeds)(nil),              // 6: band.feeds.v1beta1.CurrentFeeds
	(*CurrentFeedWithDeviations)(nil), // 7: band.feeds.v1beta1.CurrentFeedWithDeviations
	(*Price)(nil),                     // 8: band.feeds.v1beta1.Price
	(*SignalPrice)(nil),               // 9: band.feeds.v1beta1.SignalPrice
	(*ValidatorPrice)(nil),            // 10: band.feeds.v1beta1.ValidatorPrice
	(*ValidatorPriceList)(nil),        // 11: band.feeds.v1beta1.ValidatorPriceList
	(*ReferenceSourceConfig)(nil),     // 12: band.feeds.v1beta1.ReferenceSourceConfig
	(*FeedsSignatureOrder)(nil),       // 13: band.feeds.v1beta1.FeedsSignatureOrder
	(Encoder)(0),                      // 14: band.feeds.v1beta1.Encoder
}
var file_band_feeds_v1beta1_feeds_proto_depIdxs = []int32{
	2,  // 0: band.feeds.v1beta1.Vote.signals:type_name -> band.feeds.v1beta1.Signal
	4,  // 1: band.feeds.v1beta1.CurrentFeeds.feeds:type_name -> band.feeds.v1beta1.Feed
	5,  // 2: band.feeds.v1beta1.CurrentFeedWithDeviations.feeds:type_name -> band.feeds.v1beta1.FeedWithDeviation
	0,  // 3: band.feeds.v1beta1.Price.status:type_name -> band.feeds.v1beta1.PriceStatus
	1,  // 4: band.feeds.v1beta1.SignalPrice.status:type_name -> band.feeds.v1beta1.SignalPriceStatus
	1,  // 5: band.feeds.v1beta1.ValidatorPrice.signal_price_status:type_name -> band.feeds.v1beta1.SignalPriceStatus
	10, // 6: band.feeds.v1beta1.ValidatorPriceList.validator_prices:type_name -> band.feeds.v1beta1.ValidatorPrice
	14, // 7: band.feeds.v1beta1.FeedsSignatureOrder.encoder:type_name -> band.feeds.v1beta1.Encoder
	8,  // [8:8] is the sub-list for method output_type
	8,  // [8:8] 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_band_feeds_v1beta1_feeds_proto_init() }
func file_band_feeds_v1beta1_feeds_proto_init() {
	if File_band_feeds_v1beta1_feeds_proto != nil {
		return
	}
	file_band_feeds_v1beta1_encoder_proto_init()
	if !protoimpl.UnsafeEnabled {
		file_band_feeds_v1beta1_feeds_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Signal); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Vote); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Feed); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*FeedWithDeviation); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CurrentFeeds); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CurrentFeedWithDeviations); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Price); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*SignalPrice); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ValidatorPrice); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ValidatorPriceList); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ReferenceSourceConfig); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_band_feeds_v1beta1_feeds_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*FeedsSignatureOrder); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_band_feeds_v1beta1_feeds_proto_rawDesc,
			NumEnums:      2,
			NumMessages:   12,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_band_feeds_v1beta1_feeds_proto_goTypes,
		DependencyIndexes: file_band_feeds_v1beta1_feeds_proto_depIdxs,
		EnumInfos:         file_band_feeds_v1beta1_feeds_proto_enumTypes,
		MessageInfos:      file_band_feeds_v1beta1_feeds_proto_msgTypes,
	}.Build()
	File_band_feeds_v1beta1_feeds_proto = out.File
	file_band_feeds_v1beta1_feeds_proto_rawDesc = nil
	file_band_feeds_v1beta1_feeds_proto_goTypes = nil
	file_band_feeds_v1beta1_feeds_proto_depIdxs = nil
}
