status-im
/
consul
mirror of https://github.com/status-im/consul.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
consul/vendor/github.com/envoyproxy/protoc-gen-validate/validate/validate.pb.go

3155 lines
92 KiB
Go
Raw Blame History

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: validate/validate.proto
package validate // import "github.com/lyft/protoc-gen-validate/validate"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
import duration "github.com/golang/protobuf/ptypes/duration"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type FieldRules struct {
// Types that are valid to be assigned to Type:
// *FieldRules_Float
// *FieldRules_Double
// *FieldRules_Int32
// *FieldRules_Int64
// *FieldRules_Uint32
// *FieldRules_Uint64
// *FieldRules_Sint32
// *FieldRules_Sint64
// *FieldRules_Fixed32
// *FieldRules_Fixed64
// *FieldRules_Sfixed32
// *FieldRules_Sfixed64
// *FieldRules_Bool
// *FieldRules_String_
// *FieldRules_Bytes
// *FieldRules_Enum
// *FieldRules_Message
// *FieldRules_Repeated
// *FieldRules_Map
// *FieldRules_Any
// *FieldRules_Duration
// *FieldRules_Timestamp
Type isFieldRules_Type `protobuf_oneof:"type"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FieldRules) Reset() { *m = FieldRules{} }
func (m *FieldRules) String() string { return proto.CompactTextString(m) }
func (*FieldRules) ProtoMessage() {}
func (*FieldRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{0}
}
func (m *FieldRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FieldRules.Unmarshal(m, b)
}
func (m *FieldRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FieldRules.Marshal(b, m, deterministic)
}
func (dst *FieldRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_FieldRules.Merge(dst, src)
}
func (m *FieldRules) XXX_Size() int {
return xxx_messageInfo_FieldRules.Size(m)
}
func (m *FieldRules) XXX_DiscardUnknown() {
xxx_messageInfo_FieldRules.DiscardUnknown(m)
}
var xxx_messageInfo_FieldRules proto.InternalMessageInfo
type isFieldRules_Type interface {
isFieldRules_Type()
}
type FieldRules_Float struct {
Float *FloatRules `protobuf:"bytes,1,opt,name=float,oneof"`
}
type FieldRules_Double struct {
Double *DoubleRules `protobuf:"bytes,2,opt,name=double,oneof"`
}
type FieldRules_Int32 struct {
Int32 *Int32Rules `protobuf:"bytes,3,opt,name=int32,oneof"`
}
type FieldRules_Int64 struct {
Int64 *Int64Rules `protobuf:"bytes,4,opt,name=int64,oneof"`
}
type FieldRules_Uint32 struct {
Uint32 *UInt32Rules `protobuf:"bytes,5,opt,name=uint32,oneof"`
}
type FieldRules_Uint64 struct {
Uint64 *UInt64Rules `protobuf:"bytes,6,opt,name=uint64,oneof"`
}
type FieldRules_Sint32 struct {
Sint32 *SInt32Rules `protobuf:"bytes,7,opt,name=sint32,oneof"`
}
type FieldRules_Sint64 struct {
Sint64 *SInt64Rules `protobuf:"bytes,8,opt,name=sint64,oneof"`
}
type FieldRules_Fixed32 struct {
Fixed32 *Fixed32Rules `protobuf:"bytes,9,opt,name=fixed32,oneof"`
}
type FieldRules_Fixed64 struct {
Fixed64 *Fixed64Rules `protobuf:"bytes,10,opt,name=fixed64,oneof"`
}
type FieldRules_Sfixed32 struct {
Sfixed32 *SFixed32Rules `protobuf:"bytes,11,opt,name=sfixed32,oneof"`
}
type FieldRules_Sfixed64 struct {
Sfixed64 *SFixed64Rules `protobuf:"bytes,12,opt,name=sfixed64,oneof"`
}
type FieldRules_Bool struct {
Bool *BoolRules `protobuf:"bytes,13,opt,name=bool,oneof"`
}
type FieldRules_String_ struct {
String_ *StringRules `protobuf:"bytes,14,opt,name=string,oneof"`
}
type FieldRules_Bytes struct {
Bytes *BytesRules `protobuf:"bytes,15,opt,name=bytes,oneof"`
}
type FieldRules_Enum struct {
Enum *EnumRules `protobuf:"bytes,16,opt,name=enum,oneof"`
}
type FieldRules_Message struct {
Message *MessageRules `protobuf:"bytes,17,opt,name=message,oneof"`
}
type FieldRules_Repeated struct {
Repeated *RepeatedRules `protobuf:"bytes,18,opt,name=repeated,oneof"`
}
type FieldRules_Map struct {
Map *MapRules `protobuf:"bytes,19,opt,name=map,oneof"`
}
type FieldRules_Any struct {
Any *AnyRules `protobuf:"bytes,20,opt,name=any,oneof"`
}
type FieldRules_Duration struct {
Duration *DurationRules `protobuf:"bytes,21,opt,name=duration,oneof"`
}
type FieldRules_Timestamp struct {
Timestamp *TimestampRules `protobuf:"bytes,22,opt,name=timestamp,oneof"`
}
func (*FieldRules_Float) isFieldRules_Type() {}
func (*FieldRules_Double) isFieldRules_Type() {}
func (*FieldRules_Int32) isFieldRules_Type() {}
func (*FieldRules_Int64) isFieldRules_Type() {}
func (*FieldRules_Uint32) isFieldRules_Type() {}
func (*FieldRules_Uint64) isFieldRules_Type() {}
func (*FieldRules_Sint32) isFieldRules_Type() {}
func (*FieldRules_Sint64) isFieldRules_Type() {}
func (*FieldRules_Fixed32) isFieldRules_Type() {}
func (*FieldRules_Fixed64) isFieldRules_Type() {}
func (*FieldRules_Sfixed32) isFieldRules_Type() {}
func (*FieldRules_Sfixed64) isFieldRules_Type() {}
func (*FieldRules_Bool) isFieldRules_Type() {}
func (*FieldRules_String_) isFieldRules_Type() {}
func (*FieldRules_Bytes) isFieldRules_Type() {}
func (*FieldRules_Enum) isFieldRules_Type() {}
func (*FieldRules_Message) isFieldRules_Type() {}
func (*FieldRules_Repeated) isFieldRules_Type() {}
func (*FieldRules_Map) isFieldRules_Type() {}
func (*FieldRules_Any) isFieldRules_Type() {}
func (*FieldRules_Duration) isFieldRules_Type() {}
func (*FieldRules_Timestamp) isFieldRules_Type() {}
func (m *FieldRules) GetType() isFieldRules_Type {
if m != nil {
return m.Type
}
return nil
}
func (m *FieldRules) GetFloat() *FloatRules {
if x, ok := m.GetType().(*FieldRules_Float); ok {
return x.Float
}
return nil
}
func (m *FieldRules) GetDouble() *DoubleRules {
if x, ok := m.GetType().(*FieldRules_Double); ok {
return x.Double
}
return nil
}
func (m *FieldRules) GetInt32() *Int32Rules {
if x, ok := m.GetType().(*FieldRules_Int32); ok {
return x.Int32
}
return nil
}
func (m *FieldRules) GetInt64() *Int64Rules {
if x, ok := m.GetType().(*FieldRules_Int64); ok {
return x.Int64
}
return nil
}
func (m *FieldRules) GetUint32() *UInt32Rules {
if x, ok := m.GetType().(*FieldRules_Uint32); ok {
return x.Uint32
}
return nil
}
func (m *FieldRules) GetUint64() *UInt64Rules {
if x, ok := m.GetType().(*FieldRules_Uint64); ok {
return x.Uint64
}
return nil
}
func (m *FieldRules) GetSint32() *SInt32Rules {
if x, ok := m.GetType().(*FieldRules_Sint32); ok {
return x.Sint32
}
return nil
}
func (m *FieldRules) GetSint64() *SInt64Rules {
if x, ok := m.GetType().(*FieldRules_Sint64); ok {
return x.Sint64
}
return nil
}
func (m *FieldRules) GetFixed32() *Fixed32Rules {
if x, ok := m.GetType().(*FieldRules_Fixed32); ok {
return x.Fixed32
}
return nil
}
func (m *FieldRules) GetFixed64() *Fixed64Rules {
if x, ok := m.GetType().(*FieldRules_Fixed64); ok {
return x.Fixed64
}
return nil
}
func (m *FieldRules) GetSfixed32() *SFixed32Rules {
if x, ok := m.GetType().(*FieldRules_Sfixed32); ok {
return x.Sfixed32
}
return nil
}
func (m *FieldRules) GetSfixed64() *SFixed64Rules {
if x, ok := m.GetType().(*FieldRules_Sfixed64); ok {
return x.Sfixed64
}
return nil
}
func (m *FieldRules) GetBool() *BoolRules {
if x, ok := m.GetType().(*FieldRules_Bool); ok {
return x.Bool
}
return nil
}
func (m *FieldRules) GetString_() *StringRules {
if x, ok := m.GetType().(*FieldRules_String_); ok {
return x.String_
}
return nil
}
func (m *FieldRules) GetBytes() *BytesRules {
if x, ok := m.GetType().(*FieldRules_Bytes); ok {
return x.Bytes
}
return nil
}
func (m *FieldRules) GetEnum() *EnumRules {
if x, ok := m.GetType().(*FieldRules_Enum); ok {
return x.Enum
}
return nil
}
func (m *FieldRules) GetMessage() *MessageRules {
if x, ok := m.GetType().(*FieldRules_Message); ok {
return x.Message
}
return nil
}
func (m *FieldRules) GetRepeated() *RepeatedRules {
if x, ok := m.GetType().(*FieldRules_Repeated); ok {
return x.Repeated
}
return nil
}
func (m *FieldRules) GetMap() *MapRules {
if x, ok := m.GetType().(*FieldRules_Map); ok {
return x.Map
}
return nil
}
func (m *FieldRules) GetAny() *AnyRules {
if x, ok := m.GetType().(*FieldRules_Any); ok {
return x.Any
}
return nil
}
func (m *FieldRules) GetDuration() *DurationRules {
if x, ok := m.GetType().(*FieldRules_Duration); ok {
return x.Duration
}
return nil
}
func (m *FieldRules) GetTimestamp() *TimestampRules {
if x, ok := m.GetType().(*FieldRules_Timestamp); ok {
return x.Timestamp
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*FieldRules) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _FieldRules_OneofMarshaler, _FieldRules_OneofUnmarshaler, _FieldRules_OneofSizer, []interface{}{
(*FieldRules_Float)(nil),
(*FieldRules_Double)(nil),
(*FieldRules_Int32)(nil),
(*FieldRules_Int64)(nil),
(*FieldRules_Uint32)(nil),
(*FieldRules_Uint64)(nil),
(*FieldRules_Sint32)(nil),
(*FieldRules_Sint64)(nil),
(*FieldRules_Fixed32)(nil),
(*FieldRules_Fixed64)(nil),
(*FieldRules_Sfixed32)(nil),
(*FieldRules_Sfixed64)(nil),
(*FieldRules_Bool)(nil),
(*FieldRules_String_)(nil),
(*FieldRules_Bytes)(nil),
(*FieldRules_Enum)(nil),
(*FieldRules_Message)(nil),
(*FieldRules_Repeated)(nil),
(*FieldRules_Map)(nil),
(*FieldRules_Any)(nil),
(*FieldRules_Duration)(nil),
(*FieldRules_Timestamp)(nil),
}
}
func _FieldRules_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*FieldRules)
// type
switch x := m.Type.(type) {
case *FieldRules_Float:
b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Float); err != nil {
return err
}
case *FieldRules_Double:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Double); err != nil {
return err
}
case *FieldRules_Int32:
b.EncodeVarint(3<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Int32); err != nil {
return err
}
case *FieldRules_Int64:
b.EncodeVarint(4<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Int64); err != nil {
return err
}
case *FieldRules_Uint32:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Uint32); err != nil {
return err
}
case *FieldRules_Uint64:
b.EncodeVarint(6<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Uint64); err != nil {
return err
}
case *FieldRules_Sint32:
b.EncodeVarint(7<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Sint32); err != nil {
return err
}
case *FieldRules_Sint64:
b.EncodeVarint(8<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Sint64); err != nil {
return err
}
case *FieldRules_Fixed32:
b.EncodeVarint(9<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Fixed32); err != nil {
return err
}
case *FieldRules_Fixed64:
b.EncodeVarint(10<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Fixed64); err != nil {
return err
}
case *FieldRules_Sfixed32:
b.EncodeVarint(11<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Sfixed32); err != nil {
return err
}
case *FieldRules_Sfixed64:
b.EncodeVarint(12<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Sfixed64); err != nil {
return err
}
case *FieldRules_Bool:
b.EncodeVarint(13<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Bool); err != nil {
return err
}
case *FieldRules_String_:
b.EncodeVarint(14<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.String_); err != nil {
return err
}
case *FieldRules_Bytes:
b.EncodeVarint(15<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Bytes); err != nil {
return err
}
case *FieldRules_Enum:
b.EncodeVarint(16<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Enum); err != nil {
return err
}
case *FieldRules_Message:
b.EncodeVarint(17<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Message); err != nil {
return err
}
case *FieldRules_Repeated:
b.EncodeVarint(18<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Repeated); err != nil {
return err
}
case *FieldRules_Map:
b.EncodeVarint(19<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Map); err != nil {
return err
}
case *FieldRules_Any:
b.EncodeVarint(20<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Any); err != nil {
return err
}
case *FieldRules_Duration:
b.EncodeVarint(21<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Duration); err != nil {
return err
}
case *FieldRules_Timestamp:
b.EncodeVarint(22<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Timestamp); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("FieldRules.Type has unexpected type %T", x)
}
return nil
}
func _FieldRules_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*FieldRules)
switch tag {
case 1: // type.float
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(FloatRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Float{msg}
return true, err
case 2: // type.double
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(DoubleRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Double{msg}
return true, err
case 3: // type.int32
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Int32Rules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Int32{msg}
return true, err
case 4: // type.int64
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Int64Rules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Int64{msg}
return true, err
case 5: // type.uint32
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(UInt32Rules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Uint32{msg}
return true, err
case 6: // type.uint64
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(UInt64Rules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Uint64{msg}
return true, err
case 7: // type.sint32
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(SInt32Rules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Sint32{msg}
return true, err
case 8: // type.sint64
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(SInt64Rules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Sint64{msg}
return true, err
case 9: // type.fixed32
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Fixed32Rules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Fixed32{msg}
return true, err
case 10: // type.fixed64
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Fixed64Rules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Fixed64{msg}
return true, err
case 11: // type.sfixed32
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(SFixed32Rules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Sfixed32{msg}
return true, err
case 12: // type.sfixed64
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(SFixed64Rules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Sfixed64{msg}
return true, err
case 13: // type.bool
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(BoolRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Bool{msg}
return true, err
case 14: // type.string
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(StringRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_String_{msg}
return true, err
case 15: // type.bytes
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(BytesRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Bytes{msg}
return true, err
case 16: // type.enum
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(EnumRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Enum{msg}
return true, err
case 17: // type.message
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(MessageRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Message{msg}
return true, err
case 18: // type.repeated
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(RepeatedRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Repeated{msg}
return true, err
case 19: // type.map
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(MapRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Map{msg}
return true, err
case 20: // type.any
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(AnyRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Any{msg}
return true, err
case 21: // type.duration
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(DurationRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Duration{msg}
return true, err
case 22: // type.timestamp
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(TimestampRules)
err := b.DecodeMessage(msg)
m.Type = &FieldRules_Timestamp{msg}
return true, err
default:
return false, nil
}
}
func _FieldRules_OneofSizer(msg proto.Message) (n int) {
m := msg.(*FieldRules)
// type
switch x := m.Type.(type) {
case *FieldRules_Float:
s := proto.Size(x.Float)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Double:
s := proto.Size(x.Double)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Int32:
s := proto.Size(x.Int32)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Int64:
s := proto.Size(x.Int64)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Uint32:
s := proto.Size(x.Uint32)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Uint64:
s := proto.Size(x.Uint64)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Sint32:
s := proto.Size(x.Sint32)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Sint64:
s := proto.Size(x.Sint64)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Fixed32:
s := proto.Size(x.Fixed32)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Fixed64:
s := proto.Size(x.Fixed64)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Sfixed32:
s := proto.Size(x.Sfixed32)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Sfixed64:
s := proto.Size(x.Sfixed64)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Bool:
s := proto.Size(x.Bool)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_String_:
s := proto.Size(x.String_)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Bytes:
s := proto.Size(x.Bytes)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Enum:
s := proto.Size(x.Enum)
n += 2 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Message:
s := proto.Size(x.Message)
n += 2 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Repeated:
s := proto.Size(x.Repeated)
n += 2 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Map:
s := proto.Size(x.Map)
n += 2 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Any:
s := proto.Size(x.Any)
n += 2 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Duration:
s := proto.Size(x.Duration)
n += 2 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case *FieldRules_Timestamp:
s := proto.Size(x.Timestamp)
n += 2 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
type FloatRules struct {
Const *float32 `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
Lt *float32 `protobuf:"fixed32,2,opt,name=lt" json:"lt,omitempty"`
Lte *float32 `protobuf:"fixed32,3,opt,name=lte" json:"lte,omitempty"`
Gt *float32 `protobuf:"fixed32,4,opt,name=gt" json:"gt,omitempty"`
Gte *float32 `protobuf:"fixed32,5,opt,name=gte" json:"gte,omitempty"`
In []float32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
NotIn []float32 `protobuf:"fixed32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FloatRules) Reset() { *m = FloatRules{} }
func (m *FloatRules) String() string { return proto.CompactTextString(m) }
func (*FloatRules) ProtoMessage() {}
func (*FloatRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{1}
}
func (m *FloatRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FloatRules.Unmarshal(m, b)
}
func (m *FloatRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FloatRules.Marshal(b, m, deterministic)
}
func (dst *FloatRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_FloatRules.Merge(dst, src)
}
func (m *FloatRules) XXX_Size() int {
return xxx_messageInfo_FloatRules.Size(m)
}
func (m *FloatRules) XXX_DiscardUnknown() {
xxx_messageInfo_FloatRules.DiscardUnknown(m)
}
var xxx_messageInfo_FloatRules proto.InternalMessageInfo
func (m *FloatRules) GetConst() float32 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *FloatRules) GetLt() float32 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *FloatRules) GetLte() float32 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *FloatRules) GetGt() float32 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *FloatRules) GetGte() float32 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *FloatRules) GetIn() []float32 {
if m != nil {
return m.In
}
return nil
}
func (m *FloatRules) GetNotIn() []float32 {
if m != nil {
return m.NotIn
}
return nil
}
type DoubleRules struct {
Const *float64 `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
Lt *float64 `protobuf:"fixed64,2,opt,name=lt" json:"lt,omitempty"`
Lte *float64 `protobuf:"fixed64,3,opt,name=lte" json:"lte,omitempty"`
Gt *float64 `protobuf:"fixed64,4,opt,name=gt" json:"gt,omitempty"`
Gte *float64 `protobuf:"fixed64,5,opt,name=gte" json:"gte,omitempty"`
In []float64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
NotIn []float64 `protobuf:"fixed64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DoubleRules) Reset() { *m = DoubleRules{} }
func (m *DoubleRules) String() string { return proto.CompactTextString(m) }
func (*DoubleRules) ProtoMessage() {}
func (*DoubleRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{2}
}
func (m *DoubleRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DoubleRules.Unmarshal(m, b)
}
func (m *DoubleRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DoubleRules.Marshal(b, m, deterministic)
}
func (dst *DoubleRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_DoubleRules.Merge(dst, src)
}
func (m *DoubleRules) XXX_Size() int {
return xxx_messageInfo_DoubleRules.Size(m)
}
func (m *DoubleRules) XXX_DiscardUnknown() {
xxx_messageInfo_DoubleRules.DiscardUnknown(m)
}
var xxx_messageInfo_DoubleRules proto.InternalMessageInfo
func (m *DoubleRules) GetConst() float64 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *DoubleRules) GetLt() float64 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *DoubleRules) GetLte() float64 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *DoubleRules) GetGt() float64 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *DoubleRules) GetGte() float64 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *DoubleRules) GetIn() []float64 {
if m != nil {
return m.In
}
return nil
}
func (m *DoubleRules) GetNotIn() []float64 {
if m != nil {
return m.NotIn
}
return nil
}
type Int32Rules struct {
Const *int32 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
Lt *int32 `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
Lte *int32 `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
Gt *int32 `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
Gte *int32 `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
In []int32 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
NotIn []int32 `protobuf:"varint,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Int32Rules) Reset() { *m = Int32Rules{} }
func (m *Int32Rules) String() string { return proto.CompactTextString(m) }
func (*Int32Rules) ProtoMessage() {}
func (*Int32Rules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{3}
}
func (m *Int32Rules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Int32Rules.Unmarshal(m, b)
}
func (m *Int32Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Int32Rules.Marshal(b, m, deterministic)
}
func (dst *Int32Rules) XXX_Merge(src proto.Message) {
xxx_messageInfo_Int32Rules.Merge(dst, src)
}
func (m *Int32Rules) XXX_Size() int {
return xxx_messageInfo_Int32Rules.Size(m)
}
func (m *Int32Rules) XXX_DiscardUnknown() {
xxx_messageInfo_Int32Rules.DiscardUnknown(m)
}
var xxx_messageInfo_Int32Rules proto.InternalMessageInfo
func (m *Int32Rules) GetConst() int32 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *Int32Rules) GetLt() int32 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *Int32Rules) GetLte() int32 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *Int32Rules) GetGt() int32 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *Int32Rules) GetGte() int32 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *Int32Rules) GetIn() []int32 {
if m != nil {
return m.In
}
return nil
}
func (m *Int32Rules) GetNotIn() []int32 {
if m != nil {
return m.NotIn
}
return nil
}
type Int64Rules struct {
Const *int64 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
Lt *int64 `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
Lte *int64 `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
Gt *int64 `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
Gte *int64 `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
In []int64 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
NotIn []int64 `protobuf:"varint,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Int64Rules) Reset() { *m = Int64Rules{} }
func (m *Int64Rules) String() string { return proto.CompactTextString(m) }
func (*Int64Rules) ProtoMessage() {}
func (*Int64Rules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{4}
}
func (m *Int64Rules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Int64Rules.Unmarshal(m, b)
}
func (m *Int64Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Int64Rules.Marshal(b, m, deterministic)
}
func (dst *Int64Rules) XXX_Merge(src proto.Message) {
xxx_messageInfo_Int64Rules.Merge(dst, src)
}
func (m *Int64Rules) XXX_Size() int {
return xxx_messageInfo_Int64Rules.Size(m)
}
func (m *Int64Rules) XXX_DiscardUnknown() {
xxx_messageInfo_Int64Rules.DiscardUnknown(m)
}
var xxx_messageInfo_Int64Rules proto.InternalMessageInfo
func (m *Int64Rules) GetConst() int64 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *Int64Rules) GetLt() int64 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *Int64Rules) GetLte() int64 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *Int64Rules) GetGt() int64 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *Int64Rules) GetGte() int64 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *Int64Rules) GetIn() []int64 {
if m != nil {
return m.In
}
return nil
}
func (m *Int64Rules) GetNotIn() []int64 {
if m != nil {
return m.NotIn
}
return nil
}
type UInt32Rules struct {
Const *uint32 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
Lt *uint32 `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
Lte *uint32 `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
Gt *uint32 `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
Gte *uint32 `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
In []uint32 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
NotIn []uint32 `protobuf:"varint,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UInt32Rules) Reset() { *m = UInt32Rules{} }
func (m *UInt32Rules) String() string { return proto.CompactTextString(m) }
func (*UInt32Rules) ProtoMessage() {}
func (*UInt32Rules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{5}
}
func (m *UInt32Rules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UInt32Rules.Unmarshal(m, b)
}
func (m *UInt32Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UInt32Rules.Marshal(b, m, deterministic)
}
func (dst *UInt32Rules) XXX_Merge(src proto.Message) {
xxx_messageInfo_UInt32Rules.Merge(dst, src)
}
func (m *UInt32Rules) XXX_Size() int {
return xxx_messageInfo_UInt32Rules.Size(m)
}
func (m *UInt32Rules) XXX_DiscardUnknown() {
xxx_messageInfo_UInt32Rules.DiscardUnknown(m)
}
var xxx_messageInfo_UInt32Rules proto.InternalMessageInfo
func (m *UInt32Rules) GetConst() uint32 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *UInt32Rules) GetLt() uint32 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *UInt32Rules) GetLte() uint32 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *UInt32Rules) GetGt() uint32 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *UInt32Rules) GetGte() uint32 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *UInt32Rules) GetIn() []uint32 {
if m != nil {
return m.In
}
return nil
}
func (m *UInt32Rules) GetNotIn() []uint32 {
if m != nil {
return m.NotIn
}
return nil
}
type UInt64Rules struct {
Const *uint64 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
Lt *uint64 `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
Lte *uint64 `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
Gt *uint64 `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
Gte *uint64 `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
In []uint64 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
NotIn []uint64 `protobuf:"varint,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UInt64Rules) Reset() { *m = UInt64Rules{} }
func (m *UInt64Rules) String() string { return proto.CompactTextString(m) }
func (*UInt64Rules) ProtoMessage() {}
func (*UInt64Rules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{6}
}
func (m *UInt64Rules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UInt64Rules.Unmarshal(m, b)
}
func (m *UInt64Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UInt64Rules.Marshal(b, m, deterministic)
}
func (dst *UInt64Rules) XXX_Merge(src proto.Message) {
xxx_messageInfo_UInt64Rules.Merge(dst, src)
}
func (m *UInt64Rules) XXX_Size() int {
return xxx_messageInfo_UInt64Rules.Size(m)
}
func (m *UInt64Rules) XXX_DiscardUnknown() {
xxx_messageInfo_UInt64Rules.DiscardUnknown(m)
}
var xxx_messageInfo_UInt64Rules proto.InternalMessageInfo
func (m *UInt64Rules) GetConst() uint64 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *UInt64Rules) GetLt() uint64 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *UInt64Rules) GetLte() uint64 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *UInt64Rules) GetGt() uint64 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *UInt64Rules) GetGte() uint64 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *UInt64Rules) GetIn() []uint64 {
if m != nil {
return m.In
}
return nil
}
func (m *UInt64Rules) GetNotIn() []uint64 {
if m != nil {
return m.NotIn
}
return nil
}
type SInt32Rules struct {
Const *int32 `protobuf:"zigzag32,1,opt,name=const" json:"const,omitempty"`
Lt *int32 `protobuf:"zigzag32,2,opt,name=lt" json:"lt,omitempty"`
Lte *int32 `protobuf:"zigzag32,3,opt,name=lte" json:"lte,omitempty"`
Gt *int32 `protobuf:"zigzag32,4,opt,name=gt" json:"gt,omitempty"`
Gte *int32 `protobuf:"zigzag32,5,opt,name=gte" json:"gte,omitempty"`
In []int32 `protobuf:"zigzag32,6,rep,name=in" json:"in,omitempty"`
NotIn []int32 `protobuf:"zigzag32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SInt32Rules) Reset() { *m = SInt32Rules{} }
func (m *SInt32Rules) String() string { return proto.CompactTextString(m) }
func (*SInt32Rules) ProtoMessage() {}
func (*SInt32Rules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{7}
}
func (m *SInt32Rules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SInt32Rules.Unmarshal(m, b)
}
func (m *SInt32Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SInt32Rules.Marshal(b, m, deterministic)
}
func (dst *SInt32Rules) XXX_Merge(src proto.Message) {
xxx_messageInfo_SInt32Rules.Merge(dst, src)
}
func (m *SInt32Rules) XXX_Size() int {
return xxx_messageInfo_SInt32Rules.Size(m)
}
func (m *SInt32Rules) XXX_DiscardUnknown() {
xxx_messageInfo_SInt32Rules.DiscardUnknown(m)
}
var xxx_messageInfo_SInt32Rules proto.InternalMessageInfo
func (m *SInt32Rules) GetConst() int32 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *SInt32Rules) GetLt() int32 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *SInt32Rules) GetLte() int32 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *SInt32Rules) GetGt() int32 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *SInt32Rules) GetGte() int32 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *SInt32Rules) GetIn() []int32 {
if m != nil {
return m.In
}
return nil
}
func (m *SInt32Rules) GetNotIn() []int32 {
if m != nil {
return m.NotIn
}
return nil
}
type SInt64Rules struct {
Const *int64 `protobuf:"zigzag64,1,opt,name=const" json:"const,omitempty"`
Lt *int64 `protobuf:"zigzag64,2,opt,name=lt" json:"lt,omitempty"`
Lte *int64 `protobuf:"zigzag64,3,opt,name=lte" json:"lte,omitempty"`
Gt *int64 `protobuf:"zigzag64,4,opt,name=gt" json:"gt,omitempty"`
Gte *int64 `protobuf:"zigzag64,5,opt,name=gte" json:"gte,omitempty"`
In []int64 `protobuf:"zigzag64,6,rep,name=in" json:"in,omitempty"`
NotIn []int64 `protobuf:"zigzag64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SInt64Rules) Reset() { *m = SInt64Rules{} }
func (m *SInt64Rules) String() string { return proto.CompactTextString(m) }
func (*SInt64Rules) ProtoMessage() {}
func (*SInt64Rules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{8}
}
func (m *SInt64Rules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SInt64Rules.Unmarshal(m, b)
}
func (m *SInt64Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SInt64Rules.Marshal(b, m, deterministic)
}
func (dst *SInt64Rules) XXX_Merge(src proto.Message) {
xxx_messageInfo_SInt64Rules.Merge(dst, src)
}
func (m *SInt64Rules) XXX_Size() int {
return xxx_messageInfo_SInt64Rules.Size(m)
}
func (m *SInt64Rules) XXX_DiscardUnknown() {
xxx_messageInfo_SInt64Rules.DiscardUnknown(m)
}
var xxx_messageInfo_SInt64Rules proto.InternalMessageInfo
func (m *SInt64Rules) GetConst() int64 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *SInt64Rules) GetLt() int64 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *SInt64Rules) GetLte() int64 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *SInt64Rules) GetGt() int64 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *SInt64Rules) GetGte() int64 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *SInt64Rules) GetIn() []int64 {
if m != nil {
return m.In
}
return nil
}
func (m *SInt64Rules) GetNotIn() []int64 {
if m != nil {
return m.NotIn
}
return nil
}
type Fixed32Rules struct {
Const *uint32 `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
Lt *uint32 `protobuf:"fixed32,2,opt,name=lt" json:"lt,omitempty"`
Lte *uint32 `protobuf:"fixed32,3,opt,name=lte" json:"lte,omitempty"`
Gt *uint32 `protobuf:"fixed32,4,opt,name=gt" json:"gt,omitempty"`
Gte *uint32 `protobuf:"fixed32,5,opt,name=gte" json:"gte,omitempty"`
In []uint32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
NotIn []uint32 `protobuf:"fixed32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Fixed32Rules) Reset() { *m = Fixed32Rules{} }
func (m *Fixed32Rules) String() string { return proto.CompactTextString(m) }
func (*Fixed32Rules) ProtoMessage() {}
func (*Fixed32Rules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{9}
}
func (m *Fixed32Rules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Fixed32Rules.Unmarshal(m, b)
}
func (m *Fixed32Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Fixed32Rules.Marshal(b, m, deterministic)
}
func (dst *Fixed32Rules) XXX_Merge(src proto.Message) {
xxx_messageInfo_Fixed32Rules.Merge(dst, src)
}
func (m *Fixed32Rules) XXX_Size() int {
return xxx_messageInfo_Fixed32Rules.Size(m)
}
func (m *Fixed32Rules) XXX_DiscardUnknown() {
xxx_messageInfo_Fixed32Rules.DiscardUnknown(m)
}
var xxx_messageInfo_Fixed32Rules proto.InternalMessageInfo
func (m *Fixed32Rules) GetConst() uint32 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *Fixed32Rules) GetLt() uint32 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *Fixed32Rules) GetLte() uint32 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *Fixed32Rules) GetGt() uint32 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *Fixed32Rules) GetGte() uint32 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *Fixed32Rules) GetIn() []uint32 {
if m != nil {
return m.In
}
return nil
}
func (m *Fixed32Rules) GetNotIn() []uint32 {
if m != nil {
return m.NotIn
}
return nil
}
type Fixed64Rules struct {
Const *uint64 `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
Lt *uint64 `protobuf:"fixed64,2,opt,name=lt" json:"lt,omitempty"`
Lte *uint64 `protobuf:"fixed64,3,opt,name=lte" json:"lte,omitempty"`
Gt *uint64 `protobuf:"fixed64,4,opt,name=gt" json:"gt,omitempty"`
Gte *uint64 `protobuf:"fixed64,5,opt,name=gte" json:"gte,omitempty"`
In []uint64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
NotIn []uint64 `protobuf:"fixed64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Fixed64Rules) Reset() { *m = Fixed64Rules{} }
func (m *Fixed64Rules) String() string { return proto.CompactTextString(m) }
func (*Fixed64Rules) ProtoMessage() {}
func (*Fixed64Rules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{10}
}
func (m *Fixed64Rules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Fixed64Rules.Unmarshal(m, b)
}
func (m *Fixed64Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Fixed64Rules.Marshal(b, m, deterministic)
}
func (dst *Fixed64Rules) XXX_Merge(src proto.Message) {
xxx_messageInfo_Fixed64Rules.Merge(dst, src)
}
func (m *Fixed64Rules) XXX_Size() int {
return xxx_messageInfo_Fixed64Rules.Size(m)
}
func (m *Fixed64Rules) XXX_DiscardUnknown() {
xxx_messageInfo_Fixed64Rules.DiscardUnknown(m)
}
var xxx_messageInfo_Fixed64Rules proto.InternalMessageInfo
func (m *Fixed64Rules) GetConst() uint64 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *Fixed64Rules) GetLt() uint64 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *Fixed64Rules) GetLte() uint64 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *Fixed64Rules) GetGt() uint64 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *Fixed64Rules) GetGte() uint64 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *Fixed64Rules) GetIn() []uint64 {
if m != nil {
return m.In
}
return nil
}
func (m *Fixed64Rules) GetNotIn() []uint64 {
if m != nil {
return m.NotIn
}
return nil
}
type SFixed32Rules struct {
Const *int32 `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
Lt *int32 `protobuf:"fixed32,2,opt,name=lt" json:"lt,omitempty"`
Lte *int32 `protobuf:"fixed32,3,opt,name=lte" json:"lte,omitempty"`
Gt *int32 `protobuf:"fixed32,4,opt,name=gt" json:"gt,omitempty"`
Gte *int32 `protobuf:"fixed32,5,opt,name=gte" json:"gte,omitempty"`
In []int32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
NotIn []int32 `protobuf:"fixed32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SFixed32Rules) Reset() { *m = SFixed32Rules{} }
func (m *SFixed32Rules) String() string { return proto.CompactTextString(m) }
func (*SFixed32Rules) ProtoMessage() {}
func (*SFixed32Rules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{11}
}
func (m *SFixed32Rules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SFixed32Rules.Unmarshal(m, b)
}
func (m *SFixed32Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SFixed32Rules.Marshal(b, m, deterministic)
}
func (dst *SFixed32Rules) XXX_Merge(src proto.Message) {
xxx_messageInfo_SFixed32Rules.Merge(dst, src)
}
func (m *SFixed32Rules) XXX_Size() int {
return xxx_messageInfo_SFixed32Rules.Size(m)
}
func (m *SFixed32Rules) XXX_DiscardUnknown() {
xxx_messageInfo_SFixed32Rules.DiscardUnknown(m)
}
var xxx_messageInfo_SFixed32Rules proto.InternalMessageInfo
func (m *SFixed32Rules) GetConst() int32 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *SFixed32Rules) GetLt() int32 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *SFixed32Rules) GetLte() int32 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *SFixed32Rules) GetGt() int32 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *SFixed32Rules) GetGte() int32 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *SFixed32Rules) GetIn() []int32 {
if m != nil {
return m.In
}
return nil
}
func (m *SFixed32Rules) GetNotIn() []int32 {
if m != nil {
return m.NotIn
}
return nil
}
type SFixed64Rules struct {
Const *int64 `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
Lt *int64 `protobuf:"fixed64,2,opt,name=lt" json:"lt,omitempty"`
Lte *int64 `protobuf:"fixed64,3,opt,name=lte" json:"lte,omitempty"`
Gt *int64 `protobuf:"fixed64,4,opt,name=gt" json:"gt,omitempty"`
Gte *int64 `protobuf:"fixed64,5,opt,name=gte" json:"gte,omitempty"`
In []int64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
NotIn []int64 `protobuf:"fixed64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SFixed64Rules) Reset() { *m = SFixed64Rules{} }
func (m *SFixed64Rules) String() string { return proto.CompactTextString(m) }
func (*SFixed64Rules) ProtoMessage() {}
func (*SFixed64Rules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{12}
}
func (m *SFixed64Rules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SFixed64Rules.Unmarshal(m, b)
}
func (m *SFixed64Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SFixed64Rules.Marshal(b, m, deterministic)
}
func (dst *SFixed64Rules) XXX_Merge(src proto.Message) {
xxx_messageInfo_SFixed64Rules.Merge(dst, src)
}
func (m *SFixed64Rules) XXX_Size() int {
return xxx_messageInfo_SFixed64Rules.Size(m)
}
func (m *SFixed64Rules) XXX_DiscardUnknown() {
xxx_messageInfo_SFixed64Rules.DiscardUnknown(m)
}
var xxx_messageInfo_SFixed64Rules proto.InternalMessageInfo
func (m *SFixed64Rules) GetConst() int64 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *SFixed64Rules) GetLt() int64 {
if m != nil && m.Lt != nil {
return *m.Lt
}
return 0
}
func (m *SFixed64Rules) GetLte() int64 {
if m != nil && m.Lte != nil {
return *m.Lte
}
return 0
}
func (m *SFixed64Rules) GetGt() int64 {
if m != nil && m.Gt != nil {
return *m.Gt
}
return 0
}
func (m *SFixed64Rules) GetGte() int64 {
if m != nil && m.Gte != nil {
return *m.Gte
}
return 0
}
func (m *SFixed64Rules) GetIn() []int64 {
if m != nil {
return m.In
}
return nil
}
func (m *SFixed64Rules) GetNotIn() []int64 {
if m != nil {
return m.NotIn
}
return nil
}
type BoolRules struct {
Const *bool `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BoolRules) Reset() { *m = BoolRules{} }
func (m *BoolRules) String() string { return proto.CompactTextString(m) }
func (*BoolRules) ProtoMessage() {}
func (*BoolRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{13}
}
func (m *BoolRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BoolRules.Unmarshal(m, b)
}
func (m *BoolRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_BoolRules.Marshal(b, m, deterministic)
}
func (dst *BoolRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_BoolRules.Merge(dst, src)
}
func (m *BoolRules) XXX_Size() int {
return xxx_messageInfo_BoolRules.Size(m)
}
func (m *BoolRules) XXX_DiscardUnknown() {
xxx_messageInfo_BoolRules.DiscardUnknown(m)
}
var xxx_messageInfo_BoolRules proto.InternalMessageInfo
func (m *BoolRules) GetConst() bool {
if m != nil && m.Const != nil {
return *m.Const
}
return false
}
type StringRules struct {
Const *string `protobuf:"bytes,1,opt,name=const" json:"const,omitempty"`
Len *uint64 `protobuf:"varint,19,opt,name=len" json:"len,omitempty"`
MinLen *uint64 `protobuf:"varint,2,opt,name=min_len,json=minLen" json:"min_len,omitempty"`
MaxLen *uint64 `protobuf:"varint,3,opt,name=max_len,json=maxLen" json:"max_len,omitempty"`
LenBytes *uint64 `protobuf:"varint,20,opt,name=len_bytes,json=lenBytes" json:"len_bytes,omitempty"`
MinBytes *uint64 `protobuf:"varint,4,opt,name=min_bytes,json=minBytes" json:"min_bytes,omitempty"`
MaxBytes *uint64 `protobuf:"varint,5,opt,name=max_bytes,json=maxBytes" json:"max_bytes,omitempty"`
Pattern *string `protobuf:"bytes,6,opt,name=pattern" json:"pattern,omitempty"`
Prefix *string `protobuf:"bytes,7,opt,name=prefix" json:"prefix,omitempty"`
Suffix *string `protobuf:"bytes,8,opt,name=suffix" json:"suffix,omitempty"`
Contains *string `protobuf:"bytes,9,opt,name=contains" json:"contains,omitempty"`
In []string `protobuf:"bytes,10,rep,name=in" json:"in,omitempty"`
NotIn []string `protobuf:"bytes,11,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
// Types that are valid to be assigned to WellKnown:
// *StringRules_Email
// *StringRules_Hostname
// *StringRules_Ip
// *StringRules_Ipv4
// *StringRules_Ipv6
// *StringRules_Uri
// *StringRules_UriRef
WellKnown isStringRules_WellKnown `protobuf_oneof:"well_known"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StringRules) Reset() { *m = StringRules{} }
func (m *StringRules) String() string { return proto.CompactTextString(m) }
func (*StringRules) ProtoMessage() {}
func (*StringRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{14}
}
func (m *StringRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StringRules.Unmarshal(m, b)
}
func (m *StringRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_StringRules.Marshal(b, m, deterministic)
}
func (dst *StringRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_StringRules.Merge(dst, src)
}
func (m *StringRules) XXX_Size() int {
return xxx_messageInfo_StringRules.Size(m)
}
func (m *StringRules) XXX_DiscardUnknown() {
xxx_messageInfo_StringRules.DiscardUnknown(m)
}
var xxx_messageInfo_StringRules proto.InternalMessageInfo
type isStringRules_WellKnown interface {
isStringRules_WellKnown()
}
type StringRules_Email struct {
Email bool `protobuf:"varint,12,opt,name=email,oneof"`
}
type StringRules_Hostname struct {
Hostname bool `protobuf:"varint,13,opt,name=hostname,oneof"`
}
type StringRules_Ip struct {
Ip bool `protobuf:"varint,14,opt,name=ip,oneof"`
}
type StringRules_Ipv4 struct {
Ipv4 bool `protobuf:"varint,15,opt,name=ipv4,oneof"`
}
type StringRules_Ipv6 struct {
Ipv6 bool `protobuf:"varint,16,opt,name=ipv6,oneof"`
}
type StringRules_Uri struct {
Uri bool `protobuf:"varint,17,opt,name=uri,oneof"`
}
type StringRules_UriRef struct {
UriRef bool `protobuf:"varint,18,opt,name=uri_ref,json=uriRef,oneof"`
}
func (*StringRules_Email) isStringRules_WellKnown() {}
func (*StringRules_Hostname) isStringRules_WellKnown() {}
func (*StringRules_Ip) isStringRules_WellKnown() {}
func (*StringRules_Ipv4) isStringRules_WellKnown() {}
func (*StringRules_Ipv6) isStringRules_WellKnown() {}
func (*StringRules_Uri) isStringRules_WellKnown() {}
func (*StringRules_UriRef) isStringRules_WellKnown() {}
func (m *StringRules) GetWellKnown() isStringRules_WellKnown {
if m != nil {
return m.WellKnown
}
return nil
}
func (m *StringRules) GetConst() string {
if m != nil && m.Const != nil {
return *m.Const
}
return ""
}
func (m *StringRules) GetLen() uint64 {
if m != nil && m.Len != nil {
return *m.Len
}
return 0
}
func (m *StringRules) GetMinLen() uint64 {
if m != nil && m.MinLen != nil {
return *m.MinLen
}
return 0
}
func (m *StringRules) GetMaxLen() uint64 {
if m != nil && m.MaxLen != nil {
return *m.MaxLen
}
return 0
}
func (m *StringRules) GetLenBytes() uint64 {
if m != nil && m.LenBytes != nil {
return *m.LenBytes
}
return 0
}
func (m *StringRules) GetMinBytes() uint64 {
if m != nil && m.MinBytes != nil {
return *m.MinBytes
}
return 0
}
func (m *StringRules) GetMaxBytes() uint64 {
if m != nil && m.MaxBytes != nil {
return *m.MaxBytes
}
return 0
}
func (m *StringRules) GetPattern() string {
if m != nil && m.Pattern != nil {
return *m.Pattern
}
return ""
}
func (m *StringRules) GetPrefix() string {
if m != nil && m.Prefix != nil {
return *m.Prefix
}
return ""
}
func (m *StringRules) GetSuffix() string {
if m != nil && m.Suffix != nil {
return *m.Suffix
}
return ""
}
func (m *StringRules) GetContains() string {
if m != nil && m.Contains != nil {
return *m.Contains
}
return ""
}
func (m *StringRules) GetIn() []string {
if m != nil {
return m.In
}
return nil
}
func (m *StringRules) GetNotIn() []string {
if m != nil {
return m.NotIn
}
return nil
}
func (m *StringRules) GetEmail() bool {
if x, ok := m.GetWellKnown().(*StringRules_Email); ok {
return x.Email
}
return false
}
func (m *StringRules) GetHostname() bool {
if x, ok := m.GetWellKnown().(*StringRules_Hostname); ok {
return x.Hostname
}
return false
}
func (m *StringRules) GetIp() bool {
if x, ok := m.GetWellKnown().(*StringRules_Ip); ok {
return x.Ip
}
return false
}
func (m *StringRules) GetIpv4() bool {
if x, ok := m.GetWellKnown().(*StringRules_Ipv4); ok {
return x.Ipv4
}
return false
}
func (m *StringRules) GetIpv6() bool {
if x, ok := m.GetWellKnown().(*StringRules_Ipv6); ok {
return x.Ipv6
}
return false
}
func (m *StringRules) GetUri() bool {
if x, ok := m.GetWellKnown().(*StringRules_Uri); ok {
return x.Uri
}
return false
}
func (m *StringRules) GetUriRef() bool {
if x, ok := m.GetWellKnown().(*StringRules_UriRef); ok {
return x.UriRef
}
return false
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*StringRules) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _StringRules_OneofMarshaler, _StringRules_OneofUnmarshaler, _StringRules_OneofSizer, []interface{}{
(*StringRules_Email)(nil),
(*StringRules_Hostname)(nil),
(*StringRules_Ip)(nil),
(*StringRules_Ipv4)(nil),
(*StringRules_Ipv6)(nil),
(*StringRules_Uri)(nil),
(*StringRules_UriRef)(nil),
}
}
func _StringRules_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*StringRules)
// well_known
switch x := m.WellKnown.(type) {
case *StringRules_Email:
t := uint64(0)
if x.Email {
t = 1
}
b.EncodeVarint(12<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *StringRules_Hostname:
t := uint64(0)
if x.Hostname {
t = 1
}
b.EncodeVarint(13<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *StringRules_Ip:
t := uint64(0)
if x.Ip {
t = 1
}
b.EncodeVarint(14<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *StringRules_Ipv4:
t := uint64(0)
if x.Ipv4 {
t = 1
}
b.EncodeVarint(15<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *StringRules_Ipv6:
t := uint64(0)
if x.Ipv6 {
t = 1
}
b.EncodeVarint(16<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *StringRules_Uri:
t := uint64(0)
if x.Uri {
t = 1
}
b.EncodeVarint(17<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *StringRules_UriRef:
t := uint64(0)
if x.UriRef {
t = 1
}
b.EncodeVarint(18<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("StringRules.WellKnown has unexpected type %T", x)
}
return nil
}
func _StringRules_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*StringRules)
switch tag {
case 12: // well_known.email
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.WellKnown = &StringRules_Email{x != 0}
return true, err
case 13: // well_known.hostname
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.WellKnown = &StringRules_Hostname{x != 0}
return true, err
case 14: // well_known.ip
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.WellKnown = &StringRules_Ip{x != 0}
return true, err
case 15: // well_known.ipv4
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.WellKnown = &StringRules_Ipv4{x != 0}
return true, err
case 16: // well_known.ipv6
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.WellKnown = &StringRules_Ipv6{x != 0}
return true, err
case 17: // well_known.uri
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.WellKnown = &StringRules_Uri{x != 0}
return true, err
case 18: // well_known.uri_ref
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.WellKnown = &StringRules_UriRef{x != 0}
return true, err
default:
return false, nil
}
}
func _StringRules_OneofSizer(msg proto.Message) (n int) {
m := msg.(*StringRules)
// well_known
switch x := m.WellKnown.(type) {
case *StringRules_Email:
n += 1 // tag and wire
n += 1
case *StringRules_Hostname:
n += 1 // tag and wire
n += 1
case *StringRules_Ip:
n += 1 // tag and wire
n += 1
case *StringRules_Ipv4:
n += 1 // tag and wire
n += 1
case *StringRules_Ipv6:
n += 2 // tag and wire
n += 1
case *StringRules_Uri:
n += 2 // tag and wire
n += 1
case *StringRules_UriRef:
n += 2 // tag and wire
n += 1
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
type BytesRules struct {
Const []byte `protobuf:"bytes,1,opt,name=const" json:"const,omitempty"`
Len *uint64 `protobuf:"varint,13,opt,name=len" json:"len,omitempty"`
MinLen *uint64 `protobuf:"varint,2,opt,name=min_len,json=minLen" json:"min_len,omitempty"`
MaxLen *uint64 `protobuf:"varint,3,opt,name=max_len,json=maxLen" json:"max_len,omitempty"`
Pattern *string `protobuf:"bytes,4,opt,name=pattern" json:"pattern,omitempty"`
Prefix []byte `protobuf:"bytes,5,opt,name=prefix" json:"prefix,omitempty"`
Suffix []byte `protobuf:"bytes,6,opt,name=suffix" json:"suffix,omitempty"`
Contains []byte `protobuf:"bytes,7,opt,name=contains" json:"contains,omitempty"`
In [][]byte `protobuf:"bytes,8,rep,name=in" json:"in,omitempty"`
NotIn [][]byte `protobuf:"bytes,9,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
// Types that are valid to be assigned to WellKnown:
// *BytesRules_Ip
// *BytesRules_Ipv4
// *BytesRules_Ipv6
WellKnown isBytesRules_WellKnown `protobuf_oneof:"well_known"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BytesRules) Reset() { *m = BytesRules{} }
func (m *BytesRules) String() string { return proto.CompactTextString(m) }
func (*BytesRules) ProtoMessage() {}
func (*BytesRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{15}
}
func (m *BytesRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BytesRules.Unmarshal(m, b)
}
func (m *BytesRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_BytesRules.Marshal(b, m, deterministic)
}
func (dst *BytesRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_BytesRules.Merge(dst, src)
}
func (m *BytesRules) XXX_Size() int {
return xxx_messageInfo_BytesRules.Size(m)
}
func (m *BytesRules) XXX_DiscardUnknown() {
xxx_messageInfo_BytesRules.DiscardUnknown(m)
}
var xxx_messageInfo_BytesRules proto.InternalMessageInfo
type isBytesRules_WellKnown interface {
isBytesRules_WellKnown()
}
type BytesRules_Ip struct {
Ip bool `protobuf:"varint,10,opt,name=ip,oneof"`
}
type BytesRules_Ipv4 struct {
Ipv4 bool `protobuf:"varint,11,opt,name=ipv4,oneof"`
}
type BytesRules_Ipv6 struct {
Ipv6 bool `protobuf:"varint,12,opt,name=ipv6,oneof"`
}
func (*BytesRules_Ip) isBytesRules_WellKnown() {}
func (*BytesRules_Ipv4) isBytesRules_WellKnown() {}
func (*BytesRules_Ipv6) isBytesRules_WellKnown() {}
func (m *BytesRules) GetWellKnown() isBytesRules_WellKnown {
if m != nil {
return m.WellKnown
}
return nil
}
func (m *BytesRules) GetConst() []byte {
if m != nil {
return m.Const
}
return nil
}
func (m *BytesRules) GetLen() uint64 {
if m != nil && m.Len != nil {
return *m.Len
}
return 0
}
func (m *BytesRules) GetMinLen() uint64 {
if m != nil && m.MinLen != nil {
return *m.MinLen
}
return 0
}
func (m *BytesRules) GetMaxLen() uint64 {
if m != nil && m.MaxLen != nil {
return *m.MaxLen
}
return 0
}
func (m *BytesRules) GetPattern() string {
if m != nil && m.Pattern != nil {
return *m.Pattern
}
return ""
}
func (m *BytesRules) GetPrefix() []byte {
if m != nil {
return m.Prefix
}
return nil
}
func (m *BytesRules) GetSuffix() []byte {
if m != nil {
return m.Suffix
}
return nil
}
func (m *BytesRules) GetContains() []byte {
if m != nil {
return m.Contains
}
return nil
}
func (m *BytesRules) GetIn() [][]byte {
if m != nil {
return m.In
}
return nil
}
func (m *BytesRules) GetNotIn() [][]byte {
if m != nil {
return m.NotIn
}
return nil
}
func (m *BytesRules) GetIp() bool {
if x, ok := m.GetWellKnown().(*BytesRules_Ip); ok {
return x.Ip
}
return false
}
func (m *BytesRules) GetIpv4() bool {
if x, ok := m.GetWellKnown().(*BytesRules_Ipv4); ok {
return x.Ipv4
}
return false
}
func (m *BytesRules) GetIpv6() bool {
if x, ok := m.GetWellKnown().(*BytesRules_Ipv6); ok {
return x.Ipv6
}
return false
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*BytesRules) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _BytesRules_OneofMarshaler, _BytesRules_OneofUnmarshaler, _BytesRules_OneofSizer, []interface{}{
(*BytesRules_Ip)(nil),
(*BytesRules_Ipv4)(nil),
(*BytesRules_Ipv6)(nil),
}
}
func _BytesRules_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*BytesRules)
// well_known
switch x := m.WellKnown.(type) {
case *BytesRules_Ip:
t := uint64(0)
if x.Ip {
t = 1
}
b.EncodeVarint(10<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *BytesRules_Ipv4:
t := uint64(0)
if x.Ipv4 {
t = 1
}
b.EncodeVarint(11<<3 | proto.WireVarint)
b.EncodeVarint(t)
case *BytesRules_Ipv6:
t := uint64(0)
if x.Ipv6 {
t = 1
}
b.EncodeVarint(12<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("BytesRules.WellKnown has unexpected type %T", x)
}
return nil
}
func _BytesRules_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*BytesRules)
switch tag {
case 10: // well_known.ip
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.WellKnown = &BytesRules_Ip{x != 0}
return true, err
case 11: // well_known.ipv4
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.WellKnown = &BytesRules_Ipv4{x != 0}
return true, err
case 12: // well_known.ipv6
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.WellKnown = &BytesRules_Ipv6{x != 0}
return true, err
default:
return false, nil
}
}
func _BytesRules_OneofSizer(msg proto.Message) (n int) {
m := msg.(*BytesRules)
// well_known
switch x := m.WellKnown.(type) {
case *BytesRules_Ip:
n += 1 // tag and wire
n += 1
case *BytesRules_Ipv4:
n += 1 // tag and wire
n += 1
case *BytesRules_Ipv6:
n += 1 // tag and wire
n += 1
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
type EnumRules struct {
Const *int32 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
DefinedOnly *bool `protobuf:"varint,2,opt,name=defined_only,json=definedOnly" json:"defined_only,omitempty"`
In []int32 `protobuf:"varint,3,rep,name=in" json:"in,omitempty"`
NotIn []int32 `protobuf:"varint,4,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *EnumRules) Reset() { *m = EnumRules{} }
func (m *EnumRules) String() string { return proto.CompactTextString(m) }
func (*EnumRules) ProtoMessage() {}
func (*EnumRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{16}
}
func (m *EnumRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_EnumRules.Unmarshal(m, b)
}
func (m *EnumRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_EnumRules.Marshal(b, m, deterministic)
}
func (dst *EnumRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_EnumRules.Merge(dst, src)
}
func (m *EnumRules) XXX_Size() int {
return xxx_messageInfo_EnumRules.Size(m)
}
func (m *EnumRules) XXX_DiscardUnknown() {
xxx_messageInfo_EnumRules.DiscardUnknown(m)
}
var xxx_messageInfo_EnumRules proto.InternalMessageInfo
func (m *EnumRules) GetConst() int32 {
if m != nil && m.Const != nil {
return *m.Const
}
return 0
}
func (m *EnumRules) GetDefinedOnly() bool {
if m != nil && m.DefinedOnly != nil {
return *m.DefinedOnly
}
return false
}
func (m *EnumRules) GetIn() []int32 {
if m != nil {
return m.In
}
return nil
}
func (m *EnumRules) GetNotIn() []int32 {
if m != nil {
return m.NotIn
}
return nil
}
type MessageRules struct {
Skip *bool `protobuf:"varint,1,opt,name=skip" json:"skip,omitempty"`
Required *bool `protobuf:"varint,2,opt,name=required" json:"required,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MessageRules) Reset() { *m = MessageRules{} }
func (m *MessageRules) String() string { return proto.CompactTextString(m) }
func (*MessageRules) ProtoMessage() {}
func (*MessageRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{17}
}
func (m *MessageRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MessageRules.Unmarshal(m, b)
}
func (m *MessageRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MessageRules.Marshal(b, m, deterministic)
}
func (dst *MessageRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_MessageRules.Merge(dst, src)
}
func (m *MessageRules) XXX_Size() int {
return xxx_messageInfo_MessageRules.Size(m)
}
func (m *MessageRules) XXX_DiscardUnknown() {
xxx_messageInfo_MessageRules.DiscardUnknown(m)
}
var xxx_messageInfo_MessageRules proto.InternalMessageInfo
func (m *MessageRules) GetSkip() bool {
if m != nil && m.Skip != nil {
return *m.Skip
}
return false
}
func (m *MessageRules) GetRequired() bool {
if m != nil && m.Required != nil {
return *m.Required
}
return false
}
type RepeatedRules struct {
MinItems *uint64 `protobuf:"varint,1,opt,name=min_items,json=minItems" json:"min_items,omitempty"`
MaxItems *uint64 `protobuf:"varint,2,opt,name=max_items,json=maxItems" json:"max_items,omitempty"`
Unique *bool `protobuf:"varint,3,opt,name=unique" json:"unique,omitempty"`
Items *FieldRules `protobuf:"bytes,4,opt,name=items" json:"items,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RepeatedRules) Reset() { *m = RepeatedRules{} }
func (m *RepeatedRules) String() string { return proto.CompactTextString(m) }
func (*RepeatedRules) ProtoMessage() {}
func (*RepeatedRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{18}
}
func (m *RepeatedRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RepeatedRules.Unmarshal(m, b)
}
func (m *RepeatedRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RepeatedRules.Marshal(b, m, deterministic)
}
func (dst *RepeatedRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_RepeatedRules.Merge(dst, src)
}
func (m *RepeatedRules) XXX_Size() int {
return xxx_messageInfo_RepeatedRules.Size(m)
}
func (m *RepeatedRules) XXX_DiscardUnknown() {
xxx_messageInfo_RepeatedRules.DiscardUnknown(m)
}
var xxx_messageInfo_RepeatedRules proto.InternalMessageInfo
func (m *RepeatedRules) GetMinItems() uint64 {
if m != nil && m.MinItems != nil {
return *m.MinItems
}
return 0
}
func (m *RepeatedRules) GetMaxItems() uint64 {
if m != nil && m.MaxItems != nil {
return *m.MaxItems
}
return 0
}
func (m *RepeatedRules) GetUnique() bool {
if m != nil && m.Unique != nil {
return *m.Unique
}
return false
}
func (m *RepeatedRules) GetItems() *FieldRules {
if m != nil {
return m.Items
}
return nil
}
type MapRules struct {
MinPairs *uint64 `protobuf:"varint,1,opt,name=min_pairs,json=minPairs" json:"min_pairs,omitempty"`
MaxPairs *uint64 `protobuf:"varint,2,opt,name=max_pairs,json=maxPairs" json:"max_pairs,omitempty"`
NoSparse *bool `protobuf:"varint,3,opt,name=no_sparse,json=noSparse" json:"no_sparse,omitempty"`
Keys *FieldRules `protobuf:"bytes,4,opt,name=keys" json:"keys,omitempty"`
Values *FieldRules `protobuf:"bytes,5,opt,name=values" json:"values,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MapRules) Reset() { *m = MapRules{} }
func (m *MapRules) String() string { return proto.CompactTextString(m) }
func (*MapRules) ProtoMessage() {}
func (*MapRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{19}
}
func (m *MapRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MapRules.Unmarshal(m, b)
}
func (m *MapRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MapRules.Marshal(b, m, deterministic)
}
func (dst *MapRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_MapRules.Merge(dst, src)
}
func (m *MapRules) XXX_Size() int {
return xxx_messageInfo_MapRules.Size(m)
}
func (m *MapRules) XXX_DiscardUnknown() {
xxx_messageInfo_MapRules.DiscardUnknown(m)
}
var xxx_messageInfo_MapRules proto.InternalMessageInfo
func (m *MapRules) GetMinPairs() uint64 {
if m != nil && m.MinPairs != nil {
return *m.MinPairs
}
return 0
}
func (m *MapRules) GetMaxPairs() uint64 {
if m != nil && m.MaxPairs != nil {
return *m.MaxPairs
}
return 0
}
func (m *MapRules) GetNoSparse() bool {
if m != nil && m.NoSparse != nil {
return *m.NoSparse
}
return false
}
func (m *MapRules) GetKeys() *FieldRules {
if m != nil {
return m.Keys
}
return nil
}
func (m *MapRules) GetValues() *FieldRules {
if m != nil {
return m.Values
}
return nil
}
type AnyRules struct {
Required *bool `protobuf:"varint,1,opt,name=required" json:"required,omitempty"`
In []string `protobuf:"bytes,2,rep,name=in" json:"in,omitempty"`
NotIn []string `protobuf:"bytes,3,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AnyRules) Reset() { *m = AnyRules{} }
func (m *AnyRules) String() string { return proto.CompactTextString(m) }
func (*AnyRules) ProtoMessage() {}
func (*AnyRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{20}
}
func (m *AnyRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AnyRules.Unmarshal(m, b)
}
func (m *AnyRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AnyRules.Marshal(b, m, deterministic)
}
func (dst *AnyRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_AnyRules.Merge(dst, src)
}
func (m *AnyRules) XXX_Size() int {
return xxx_messageInfo_AnyRules.Size(m)
}
func (m *AnyRules) XXX_DiscardUnknown() {
xxx_messageInfo_AnyRules.DiscardUnknown(m)
}
var xxx_messageInfo_AnyRules proto.InternalMessageInfo
func (m *AnyRules) GetRequired() bool {
if m != nil && m.Required != nil {
return *m.Required
}
return false
}
func (m *AnyRules) GetIn() []string {
if m != nil {
return m.In
}
return nil
}
func (m *AnyRules) GetNotIn() []string {
if m != nil {
return m.NotIn
}
return nil
}
type DurationRules struct {
Required *bool `protobuf:"varint,1,opt,name=required" json:"required,omitempty"`
Const *duration.Duration `protobuf:"bytes,2,opt,name=const" json:"const,omitempty"`
Lt *duration.Duration `protobuf:"bytes,3,opt,name=lt" json:"lt,omitempty"`
Lte *duration.Duration `protobuf:"bytes,4,opt,name=lte" json:"lte,omitempty"`
Gt *duration.Duration `protobuf:"bytes,5,opt,name=gt" json:"gt,omitempty"`
Gte *duration.Duration `protobuf:"bytes,6,opt,name=gte" json:"gte,omitempty"`
In []*duration.Duration `protobuf:"bytes,7,rep,name=in" json:"in,omitempty"`
NotIn []*duration.Duration `protobuf:"bytes,8,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DurationRules) Reset() { *m = DurationRules{} }
func (m *DurationRules) String() string { return proto.CompactTextString(m) }
func (*DurationRules) ProtoMessage() {}
func (*DurationRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{21}
}
func (m *DurationRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DurationRules.Unmarshal(m, b)
}
func (m *DurationRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DurationRules.Marshal(b, m, deterministic)
}
func (dst *DurationRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_DurationRules.Merge(dst, src)
}
func (m *DurationRules) XXX_Size() int {
return xxx_messageInfo_DurationRules.Size(m)
}
func (m *DurationRules) XXX_DiscardUnknown() {
xxx_messageInfo_DurationRules.DiscardUnknown(m)
}
var xxx_messageInfo_DurationRules proto.InternalMessageInfo
func (m *DurationRules) GetRequired() bool {
if m != nil && m.Required != nil {
return *m.Required
}
return false
}
func (m *DurationRules) GetConst() *duration.Duration {
if m != nil {
return m.Const
}
return nil
}
func (m *DurationRules) GetLt() *duration.Duration {
if m != nil {
return m.Lt
}
return nil
}
func (m *DurationRules) GetLte() *duration.Duration {
if m != nil {
return m.Lte
}
return nil
}
func (m *DurationRules) GetGt() *duration.Duration {
if m != nil {
return m.Gt
}
return nil
}
func (m *DurationRules) GetGte() *duration.Duration {
if m != nil {
return m.Gte
}
return nil
}
func (m *DurationRules) GetIn() []*duration.Duration {
if m != nil {
return m.In
}
return nil
}
func (m *DurationRules) GetNotIn() []*duration.Duration {
if m != nil {
return m.NotIn
}
return nil
}
type TimestampRules struct {
Required *bool `protobuf:"varint,1,opt,name=required" json:"required,omitempty"`
Const *timestamp.Timestamp `protobuf:"bytes,2,opt,name=const" json:"const,omitempty"`
Lt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=lt" json:"lt,omitempty"`
Lte *timestamp.Timestamp `protobuf:"bytes,4,opt,name=lte" json:"lte,omitempty"`
Gt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=gt" json:"gt,omitempty"`
Gte *timestamp.Timestamp `protobuf:"bytes,6,opt,name=gte" json:"gte,omitempty"`
LtNow *bool `protobuf:"varint,7,opt,name=lt_now,json=ltNow" json:"lt_now,omitempty"`
GtNow *bool `protobuf:"varint,8,opt,name=gt_now,json=gtNow" json:"gt_now,omitempty"`
Within *duration.Duration `protobuf:"bytes,9,opt,name=within" json:"within,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TimestampRules) Reset() { *m = TimestampRules{} }
func (m *TimestampRules) String() string { return proto.CompactTextString(m) }
func (*TimestampRules) ProtoMessage() {}
func (*TimestampRules) Descriptor() ([]byte, []int) {
return fileDescriptor_validate_42a9c75c83428773, []int{22}
}
func (m *TimestampRules) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TimestampRules.Unmarshal(m, b)
}
func (m *TimestampRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TimestampRules.Marshal(b, m, deterministic)
}
func (dst *TimestampRules) XXX_Merge(src proto.Message) {
xxx_messageInfo_TimestampRules.Merge(dst, src)
}
func (m *TimestampRules) XXX_Size() int {
return xxx_messageInfo_TimestampRules.Size(m)
}
func (m *TimestampRules) XXX_DiscardUnknown() {
xxx_messageInfo_TimestampRules.DiscardUnknown(m)
}
var xxx_messageInfo_TimestampRules proto.InternalMessageInfo
func (m *TimestampRules) GetRequired() bool {
if m != nil && m.Required != nil {
return *m.Required
}
return false
}
func (m *TimestampRules) GetConst() *timestamp.Timestamp {
if m != nil {
return m.Const
}
return nil
}
func (m *TimestampRules) GetLt() *timestamp.Timestamp {
if m != nil {
return m.Lt
}
return nil
}
func (m *TimestampRules) GetLte() *timestamp.Timestamp {
if m != nil {
return m.Lte
}
return nil
}
func (m *TimestampRules) GetGt() *timestamp.Timestamp {
if m != nil {
return m.Gt
}
return nil
}
func (m *TimestampRules) GetGte() *timestamp.Timestamp {
if m != nil {
return m.Gte
}
return nil
}
func (m *TimestampRules) GetLtNow() bool {
if m != nil && m.LtNow != nil {
return *m.LtNow
}
return false
}
func (m *TimestampRules) GetGtNow() bool {
if m != nil && m.GtNow != nil {
return *m.GtNow
}
return false
}
func (m *TimestampRules) GetWithin() *duration.Duration {
if m != nil {
return m.Within
}
return nil
}
var E_Disabled = &proto.ExtensionDesc{
ExtendedType: (*descriptor.MessageOptions)(nil),
ExtensionType: (*bool)(nil),
Field: 919191,
Name: "validate.disabled",
Tag: "varint,919191,opt,name=disabled",
Filename: "validate/validate.proto",
}
var E_Required = &proto.ExtensionDesc{
ExtendedType: (*descriptor.OneofOptions)(nil),
ExtensionType: (*bool)(nil),
Field: 919191,
Name: "validate.required",
Tag: "varint,919191,opt,name=required",
Filename: "validate/validate.proto",
}
var E_Rules = &proto.ExtensionDesc{
ExtendedType: (*descriptor.FieldOptions)(nil),
ExtensionType: (*FieldRules)(nil),
Field: 919191,
Name: "validate.rules",
Tag: "bytes,919191,opt,name=rules",
Filename: "validate/validate.proto",
}
func init() {
proto.RegisterType((*FieldRules)(nil), "validate.FieldRules")
proto.RegisterType((*FloatRules)(nil), "validate.FloatRules")
proto.RegisterType((*DoubleRules)(nil), "validate.DoubleRules")
proto.RegisterType((*Int32Rules)(nil), "validate.Int32Rules")
proto.RegisterType((*Int64Rules)(nil), "validate.Int64Rules")
proto.RegisterType((*UInt32Rules)(nil), "validate.UInt32Rules")
proto.RegisterType((*UInt64Rules)(nil), "validate.UInt64Rules")
proto.RegisterType((*SInt32Rules)(nil), "validate.SInt32Rules")
proto.RegisterType((*SInt64Rules)(nil), "validate.SInt64Rules")
proto.RegisterType((*Fixed32Rules)(nil), "validate.Fixed32Rules")
proto.RegisterType((*Fixed64Rules)(nil), "validate.Fixed64Rules")
proto.RegisterType((*SFixed32Rules)(nil), "validate.SFixed32Rules")
proto.RegisterType((*SFixed64Rules)(nil), "validate.SFixed64Rules")
proto.RegisterType((*BoolRules)(nil), "validate.BoolRules")
proto.RegisterType((*StringRules)(nil), "validate.StringRules")
proto.RegisterType((*BytesRules)(nil), "validate.BytesRules")
proto.RegisterType((*EnumRules)(nil), "validate.EnumRules")
proto.RegisterType((*MessageRules)(nil), "validate.MessageRules")
proto.RegisterType((*RepeatedRules)(nil), "validate.RepeatedRules")
proto.RegisterType((*MapRules)(nil), "validate.MapRules")
proto.RegisterType((*AnyRules)(nil), "validate.AnyRules")
proto.RegisterType((*DurationRules)(nil), "validate.DurationRules")
proto.RegisterType((*TimestampRules)(nil), "validate.TimestampRules")
proto.RegisterExtension(E_Disabled)
proto.RegisterExtension(E_Required)
proto.RegisterExtension(E_Rules)
}
func init() { proto.RegisterFile("validate/validate.proto", fileDescriptor_validate_42a9c75c83428773) }
var fileDescriptor_validate_42a9c75c83428773 = []byte{
// 1609 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x98, 0xcb, 0x6e, 0xdb, 0x46,
0x17, 0xc7, 0x3f, 0xf1, 0x26, 0x6a, 0x2c, 0x45, 0xd2, 0xc4, 0x76, 0x18, 0x7f, 0x97, 0x38, 0x5a,
0x7c, 0x70, 0x52, 0xc7, 0x4e, 0x1d, 0x57, 0x08, 0x52, 0xb4, 0x40, 0x8d, 0x34, 0x68, 0xd0, 0xa6,
0x29, 0xe8, 0x66, 0xd3, 0x8d, 0x40, 0x5b, 0x23, 0x65, 0x60, 0x6a, 0xc8, 0x90, 0x54, 0x6c, 0x3d,
0x44, 0xda, 0xee, 0xfa, 0x2c, 0x5d, 0x75, 0xdf, 0x37, 0xe9, 0xba, 0xdb, 0x2e, 0x8a, 0xb9, 0xf1,
0x72, 0x48, 0xcb, 0x8b, 0xee, 0x34, 0xe7, 0xfc, 0xcf, 0xcc, 0x0f, 0xff, 0x11, 0x67, 0x0e, 0x89,
0xee, 0xbc, 0x0f, 0x42, 0x3a, 0x0d, 0x32, 0x72, 0xa8, 0x7f, 0x1c, 0xc4, 0x49, 0x94, 0x45, 0xd8,
0xd5, 0xe3, 0x9d, 0xdd, 0x79, 0x14, 0xcd, 0x43, 0x72, 0x28, 0xe2, 0x67, 0xcb, 0xd9, 0xe1, 0x94,
0xa4, 0xe7, 0x09, 0x8d, 0xb3, 0x28, 0x91, 0xda, 0x9d, 0xff, 0xd5, 0x14, 0xcb, 0x24, 0xc8, 0x68,
0xc4, 0x54, 0xfe, 0x1e, 0xcc, 0x67, 0x74, 0x41, 0xd2, 0x2c, 0x58, 0xc4, 0x52, 0x30, 0xfa, 0xdd,
0x45, 0xe8, 0x05, 0x25, 0xe1, 0xd4, 0x5f, 0x86, 0x24, 0xc5, 0xfb, 0xc8, 0x9e, 0x85, 0x51, 0x90,
0x79, 0xad, 0xdd, 0xd6, 0xde, 0xc6, 0xd1, 0xe6, 0x41, 0xce, 0xf6, 0x82, 0x87, 0x85, 0xe8, 0xab,
0x7f, 0xf9, 0x52, 0x84, 0x0f, 0x91, 0x33, 0x8d, 0x96, 0x67, 0x21, 0xf1, 0x0c, 0x21, 0xdf, 0x2a,
0xe4, 0xcf, 0x45, 0x5c, 0xeb, 0x95, 0x8c, 0x4f, 0x4f, 0x59, 0xf6, 0xe4, 0xc8, 0x33, 0xe1, 0xf4,
0x2f, 0x79, 0x38, 0x9f, 0x5e, 0x88, 0x94, 0x7a, 0x7c, 0xec, 0x59, 0x0d, 0xea, 0xf1, 0x71, 0x59,
0x3d, 0x3e, 0xe6, 0x30, 0x4b, 0x39, 0xb9, 0x0d, 0x61, 0xde, 0x54, 0x66, 0x57, 0x32, 0x5d, 0x30,
0x3e, 0xf6, 0x9c, 0xa6, 0x82, 0x62, 0x01, 0x25, 0xe3, 0x05, 0xa9, 0x5c, 0xa1, 0x0d, 0x0b, 0x4e,
0xab, 0x2b, 0xa4, 0xf9, 0x0a, 0xa9, 0x5c, 0xc1, 0x6d, 0x2a, 0x28, 0xad, 0x20, 0x65, 0xf8, 0x08,
0xb5, 0x67, 0xf4, 0x8a, 0x4c, 0x9f, 0x1c, 0x79, 0x1d, 0x51, 0xb1, 0x5d, 0xda, 0x00, 0x99, 0xd0,
0x25, 0x5a, 0x98, 0xd7, 0x8c, 0x8f, 0x3d, 0xd4, 0x58, 0x53, 0x2c, 0xa3, 0x85, 0xf8, 0x13, 0xe4,
0xa6, 0x7a, 0xa1, 0x0d, 0x51, 0x74, 0xa7, 0x84, 0x06, 0x56, 0xca, 0xa5, 0x45, 0xd9, 0xf8, 0xd8,
0xeb, 0x36, 0x97, 0x15, 0x8b, 0xe5, 0x52, 0xfc, 0x00, 0x59, 0x67, 0x51, 0x14, 0x7a, 0x3d, 0x51,
0x72, 0xbb, 0x28, 0x39, 0x89, 0xa2, 0x50, 0xcb, 0x85, 0x44, 0x38, 0x96, 0x25, 0x94, 0xcd, 0xbd,
0x5b, 0x35, 0xc7, 0x44, 0xbc, 0x70, 0x4c, 0x0c, 0xf9, 0x7f, 0xe4, 0x6c, 0x95, 0x91, 0xd4, 0xeb,
0xc3, 0xff, 0xc8, 0x09, 0x0f, 0xe7, 0xff, 0x11, 0x21, 0xe2, 0x24, 0x84, 0x2d, 0x17, 0xde, 0x00,
0x92, 0x7c, 0xc9, 0x96, 0x8b, 0x9c, 0x84, 0x4b, 0xb8, 0xad, 0x0b, 0x92, 0xa6, 0xc1, 0x9c, 0x78,
0x43, 0x68, 0xeb, 0x2b, 0x99, 0xc8, 0x6d, 0x55, 0x42, 0xee, 0x4f, 0x42, 0x62, 0x12, 0x64, 0x64,
0xea, 0x61, 0xe8, 0x8f, 0xaf, 0x32, 0xb9, 0x3f, 0x5a, 0x8a, 0xff, 0x8f, 0xcc, 0x45, 0x10, 0x7b,
0xb7, 0x45, 0x05, 0x2e, 0x2d, 0x13, 0xc4, 0x5a, 0xcc, 0x05, 0x5c, 0x17, 0xb0, 0x95, 0xb7, 0x09,
0x75, 0x5f, 0xb0, 0x55, 0xae, 0x0b, 0xd8, 0x8a, 0x63, 0xe8, 0x63, 0xc0, 0xdb, 0x82, 0x18, 0xcf,
0x55, 0x26, 0xc7, 0xd0, 0x52, 0xfc, 0x14, 0x75, 0xf2, 0xd3, 0xc1, 0xdb, 0x16, 0x75, 0x5e, 0x51,
0xf7, 0xbd, 0x4e, 0xe9, 0xc2, 0x42, 0x7c, 0xe2, 0x20, 0x2b, 0x5b, 0xc5, 0x64, 0xf4, 0xa1, 0x85,
0x50, 0x71, 0x4e, 0xe0, 0x4d, 0x64, 0x9f, 0x47, 0x2c, 0x95, 0x87, 0x89, 0xe1, 0xcb, 0x01, 0xbe,
0x85, 0x8c, 0x30, 0x13, 0x07, 0x86, 0xe1, 0x1b, 0x61, 0x86, 0x07, 0xc8, 0x0c, 0x33, 0x22, 0x4e,
0x04, 0xc3, 0xe7, 0x3f, 0xb9, 0x62, 0x9e, 0x89, 0x87, 0xde, 0xf0, 0x8d, 0xb9, 0x50, 0xcc, 0x33,
0x22, 0x1e, 0x6b, 0xc3, 0xe7, 0x3f, 0xb9, 0x82, 0x32, 0xcf, 0xd9, 0x35, 0xb9, 0x82, 0x32, 0xbc,
0x85, 0x1c, 0x16, 0x65, 0x13, 0xca, 0xbc, 0xb6, 0x88, 0xd9, 0x2c, 0xca, 0x5e, 0xb2, 0xd1, 0x8f,
0x2d, 0xb4, 0x51, 0x3a, 0x88, 0xaa, 0x40, 0xad, 0x3a, 0x50, 0x0b, 0x02, 0xb5, 0x20, 0x50, 0x0b,
0x02, 0xb5, 0x20, 0x50, 0xab, 0x01, 0xa8, 0xa5, 0x81, 0xb8, 0x41, 0xc5, 0x49, 0x51, 0xe5, 0xb1,
0xeb, 0x3c, 0x36, 0xe4, 0xb1, 0x21, 0x8f, 0x0d, 0x79, 0x6c, 0xc8, 0x63, 0x37, 0xf0, 0xd8, 0x80,
0x47, 0x3d, 0xb4, 0x55, 0x1e, 0xb3, 0xce, 0x63, 0x42, 0x1e, 0x13, 0xf2, 0x98, 0x90, 0xc7, 0x84,
0x3c, 0x66, 0x03, 0x8f, 0x59, 0xde, 0xb0, 0x37, 0xd7, 0x19, 0xd4, 0xab, 0x03, 0xf5, 0x20, 0x50,
0x0f, 0x02, 0xf5, 0x20, 0x50, 0x0f, 0x02, 0xf5, 0x1a, 0x80, 0x7a, 0x10, 0xa8, 0xd1, 0x21, 0xab,
0x0e, 0x64, 0x41, 0x20, 0x0b, 0x02, 0x59, 0x10, 0xc8, 0x82, 0x40, 0x56, 0x03, 0x90, 0x55, 0x06,
0x3a, 0xbd, 0xce, 0xa1, 0x61, 0x1d, 0x68, 0x08, 0x81, 0x86, 0x10, 0x68, 0x08, 0x81, 0x86, 0x10,
0x68, 0xd8, 0x00, 0x34, 0x84, 0x40, 0x8d, 0x0e, 0xe1, 0x3a, 0x10, 0x86, 0x40, 0x18, 0x02, 0x61,
0x08, 0x84, 0x21, 0x10, 0x6e, 0x00, 0xc2, 0x1a, 0xe8, 0xa7, 0x16, 0xea, 0x96, 0x6f, 0xb0, 0x2a,
0x51, 0xbb, 0x4e, 0xd4, 0x86, 0x44, 0x6d, 0x48, 0xd4, 0x86, 0x44, 0x6d, 0x48, 0xd4, 0x6e, 0x20,
0x6a, 0xd7, 0x88, 0x1a, 0x3d, 0x72, 0xea, 0x44, 0x0e, 0x24, 0x72, 0x20, 0x91, 0x03, 0x89, 0x1c,
0x48, 0xe4, 0x34, 0x10, 0x39, 0x9a, 0xe8, 0xe7, 0x16, 0xea, 0x9d, 0x5e, 0x6f, 0x52, 0xbf, 0x8e,
0xd4, 0x87, 0x48, 0x7d, 0x88, 0xd4, 0x87, 0x48, 0x7d, 0x88, 0xd4, 0x6f, 0x40, 0xea, 0xd7, 0x91,
0x1a, 0x5d, 0x1a, 0xd4, 0x91, 0x06, 0x10, 0x69, 0x00, 0x91, 0x06, 0x10, 0x69, 0x00, 0x91, 0x06,
0x0d, 0x48, 0x03, 0x8d, 0x74, 0x1f, 0x75, 0xf2, 0x0e, 0xa5, 0x4a, 0xe3, 0x2a, 0x9a, 0xd1, 0x5f,
0x26, 0xda, 0x28, 0x35, 0x26, 0x55, 0x55, 0x47, 0x33, 0x73, 0x46, 0xc2, 0xc4, 0x05, 0xcf, 0xcf,
0x03, 0xc2, 0xf0, 0x1d, 0xd4, 0x5e, 0x50, 0x36, 0xe1, 0x51, 0x79, 0x6c, 0x38, 0x0b, 0xca, 0xbe,
0x51, 0x89, 0xe0, 0x4a, 0x24, 0x4c, 0x95, 0x08, 0xae, 0x78, 0xe2, 0xdf, 0xa8, 0x13, 0x12, 0x36,
0x91, 0xcd, 0xce, 0xa6, 0x48, 0xb9, 0x21, 0x61, 0xa2, 0xcb, 0xe1, 0x49, 0x3e, 0x9d, 0x4c, 0xca,
0x53, 0xc6, 0x5d, 0xd0, 0x52, 0x32, 0xb8, 0x52, 0x49, 0x5b, 0x25, 0x83, 0x2b, 0x99, 0xf4, 0x50,
0x3b, 0x0e, 0xb2, 0x8c, 0x24, 0x4c, 0x74, 0xc1, 0x1d, 0x5f, 0x0f, 0xf1, 0x36, 0x72, 0xe2, 0x84,
0xcc, 0xe8, 0x95, 0xe8, 0x76, 0x3b, 0xbe, 0x1a, 0xf1, 0x78, 0xba, 0x9c, 0xf1, 0xb8, 0x2b, 0xe3,
0x72, 0x84, 0x77, 0x90, 0x7b, 0x1e, 0xb1, 0x2c, 0xa0, 0x2c, 0x15, 0xcd, 0x6b, 0xc7, 0xcf, 0xc7,
0xca, 0x70, 0xb4, 0x6b, 0xee, 0x75, 0x80, 0xe1, 0x1b, 0x22, 0x26, 0x0d, 0xc7, 0xdb, 0xc8, 0x26,
0x8b, 0x80, 0x86, 0xa2, 0xb9, 0x74, 0x79, 0xdb, 0x26, 0x86, 0xf8, 0x3f, 0xc8, 0x7d, 0x1b, 0xa5,
0x19, 0x0b, 0x16, 0x44, 0x34, 0x91, 0x3c, 0x95, 0x47, 0xf0, 0x00, 0x19, 0x34, 0x16, 0xfd, 0x22,
0x8f, 0x1b, 0x34, 0xc6, 0x9b, 0xc8, 0xa2, 0xf1, 0xfb, 0x63, 0xd1, 0x13, 0xf2, 0x98, 0x18, 0xa9,
0xe8, 0x58, 0x34, 0x7f, 0x3a, 0x3a, 0xc6, 0x18, 0x99, 0xcb, 0x84, 0x8a, 0x1e, 0x8f, 0x07, 0xf9,
0x00, 0xdf, 0x45, 0xed, 0x65, 0x42, 0x27, 0x09, 0x99, 0x89, 0x36, 0xce, 0x15, 0xef, 0x00, 0x09,
0xf5, 0xc9, 0xec, 0xa4, 0x8b, 0xd0, 0x25, 0x09, 0xc3, 0xc9, 0x05, 0x8b, 0x2e, 0xd9, 0xe8, 0x37,
0x03, 0xa1, 0xa2, 0xcf, 0xac, 0xee, 0x7e, 0x17, 0xec, 0x7e, 0xef, 0x9f, 0xec, 0x7e, 0x69, 0x9b,
0xac, 0xeb, 0xb6, 0xc9, 0x16, 0x8b, 0xd6, 0xb7, 0xc9, 0x91, 0xf1, 0x86, 0x6d, 0x6a, 0x8b, 0x0c,
0xdc, 0x26, 0x77, 0xd7, 0xdc, 0xeb, 0x82, 0x6d, 0xea, 0x88, 0x98, 0xda, 0x26, 0x69, 0x38, 0x6a,
0x30, 0x7c, 0xa3, 0xd1, 0xf0, 0x6e, 0xd9, 0x70, 0xe0, 0xe0, 0x05, 0xea, 0xe4, 0xbd, 0xf7, 0x35,
0xfd, 0xd0, 0x7d, 0xd4, 0x9d, 0x92, 0x19, 0x65, 0x64, 0x3a, 0x89, 0x58, 0xb8, 0x12, 0x96, 0xb9,
0xfe, 0x86, 0x8a, 0xbd, 0x66, 0xe1, 0x4a, 0x81, 0x9b, 0x0d, 0xed, 0x8e, 0x55, 0x6e, 0x77, 0x3e,
0x47, 0xdd, 0x72, 0xeb, 0x8e, 0x31, 0xb2, 0xd2, 0x0b, 0x1a, 0xab, 0x47, 0x5a, 0xfc, 0xe6, 0xfe,
0x24, 0xe4, 0xdd, 0x92, 0x26, 0x64, 0xaa, 0x56, 0xca, 0xc7, 0xbc, 0x5d, 0xea, 0x55, 0xda, 0x78,
0xfd, 0xe0, 0xd1, 0x8c, 0x2c, 0x52, 0xd5, 0x13, 0xf0, 0x07, 0xef, 0x25, 0x1f, 0xeb, 0x07, 0x4f,
0x26, 0x8d, 0xfc, 0xc1, 0x93, 0xc9, 0x6d, 0xe4, 0x2c, 0x19, 0x7d, 0xb7, 0x94, 0x47, 0x97, 0xeb,
0xab, 0x11, 0x7e, 0x88, 0x6c, 0x59, 0x50, 0x7b, 0xe9, 0x2d, 0x5e, 0xd3, 0x7d, 0x29, 0x19, 0xfd,
0xda, 0x42, 0xae, 0x7e, 0x49, 0xd0, 0x28, 0x71, 0x40, 0x93, 0x32, 0xca, 0x77, 0x7c, 0xac, 0x51,
0x64, 0xb2, 0x40, 0xc9, 0x93, 0x2c, 0x9a, 0xa4, 0x71, 0x90, 0xa4, 0x9a, 0xc6, 0x65, 0xd1, 0xa9,
0x18, 0xe3, 0x3d, 0x64, 0x5d, 0x90, 0xd5, 0x7a, 0x1c, 0xa1, 0xc0, 0xfb, 0xc8, 0x79, 0x1f, 0x84,
0x4b, 0x75, 0xc8, 0x5c, 0xa7, 0x55, 0x9a, 0xd1, 0x2b, 0xe4, 0xea, 0xf7, 0x96, 0x8a, 0xe7, 0xad,
0xaa, 0xe7, 0x6a, 0x6b, 0x8d, 0x86, 0xa3, 0xc3, 0x2c, 0x1d, 0x1d, 0xa3, 0x3f, 0x0c, 0xd4, 0xab,
0xbc, 0xda, 0xac, 0x9d, 0xf4, 0x50, 0xff, 0xd1, 0xe4, 0x77, 0x8b, 0xbb, 0x07, 0xf2, 0x33, 0xc9,
0x81, 0xfe, 0x4c, 0x52, 0xbc, 0x25, 0xa9, 0xff, 0xe0, 0x03, 0x71, 0xeb, 0x98, 0x37, 0xa9, 0xf9,
0x85, 0xf4, 0x91, 0xbc, 0x90, 0xac, 0x9b, 0xb4, 0xe2, 0xae, 0x7a, 0x20, 0xee, 0x2a, 0xfb, 0xc6,
0x79, 0xe7, 0x62, 0x5e, 0x7e, 0x8d, 0x39, 0x37, 0xce, 0x3b, 0x97, 0xf3, 0xaa, 0xdb, 0x6c, 0xfd,
0xbc, 0x94, 0xe1, 0xc7, 0xb9, 0xa1, 0xee, 0x4d, 0x72, 0xe5, 0xf5, 0x9f, 0x06, 0xba, 0x55, 0x7d,
0x1d, 0x5c, 0x6b, 0xf6, 0xe3, 0xaa, 0xd9, 0x3b, 0xb5, 0xf9, 0x8b, 0xb9, 0x94, 0xdb, 0x0f, 0x4b,
0x6e, 0xaf, 0x93, 0x73, 0xbb, 0xf7, 0xcb, 0x76, 0xaf, 0x13, 0x0b, 0xbf, 0x1f, 0x96, 0xfc, 0x5e,
0x3b, 0xf3, 0x5c, 0xcc, 0x5c, 0x18, 0xbe, 0x76, 0x66, 0xee, 0xf8, 0x16, 0x72, 0xc2, 0x6c, 0xc2,
0xa2, 0x4b, 0x71, 0xaa, 0xba, 0xbe, 0x1d, 0x66, 0xdf, 0x46, 0x97, 0x3c, 0x3c, 0x97, 0x61, 0x57,
0x86, 0xe7, 0x22, 0xfc, 0x31, 0x72, 0x2e, 0x69, 0xf6, 0x56, 0x9c, 0xac, 0x37, 0xec, 0xa7, 0x12,
0x3e, 0xfb, 0x0c, 0xb9, 0x53, 0x9a, 0x06, 0x67, 0x21, 0x99, 0xe2, 0x7b, 0x35, 0xb9, 0x3a, 0xd7,
0x5e, 0xc7, 0xbc, 0x26, 0xf5, 0x7e, 0xf9, 0xf0, 0x54, 0xee, 0x82, 0x2e, 0x79, 0xf6, 0x69, 0xb1,
0x43, 0xf8, 0xbf, 0xb5, 0xf2, 0xd7, 0x8c, 0x44, 0xb3, 0x5a, 0xb1, 0x2e, 0x78, 0xf6, 0x35, 0xb2,
0x13, 0xb1, 0xcf, 0xf5, 0x4a, 0xf1, 0x68, 0x57, 0x2b, 0xaf, 0x3d, 0xb5, 0xc4, 0x1c, 0x27, 0x07,
0x3f, 0xec, 0xcf, 0x69, 0xf6, 0x76, 0x79, 0x76, 0x70, 0x1e, 0x2d, 0x0e, 0xc3, 0xd5, 0x2c, 0x93,
0x9f, 0x27, 0xcf, 0x1f, 0xcd, 0x09, 0x7b, 0x54, 0xfb, 0x2a, 0xfa, 0x77, 0x00, 0x00, 0x00, 0xff,
0xff, 0xe1, 0xd8, 0xec, 0xea, 0x29, 0x15, 0x00, 0x00,
}
Reference in New Issue View Git Blame Copy Permalink