3576 lines
108 KiB
Go
3576 lines
108 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// source: validate/validate.proto
|
|
|
|
package validate // import "github.com/envoyproxy/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
|
|
|
|
// FieldRules encapsulates the rules for each type of field. Depending on the
|
|
// field, the correct set should be used to ensure proper validations.
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// FloatRules describes the constraints applied to `float` values
|
|
type FloatRules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *float32 `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *float32 `protobuf:"fixed32,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *float32 `protobuf:"fixed32,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *float32 `protobuf:"fixed32,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *float32 `protobuf:"fixed32,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []float32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// DoubleRules describes the constraints applied to `double` values
|
|
type DoubleRules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *float64 `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *float64 `protobuf:"fixed64,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *float64 `protobuf:"fixed64,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *float64 `protobuf:"fixed64,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *float64 `protobuf:"fixed64,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []float64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// Int32Rules describes the constraints applied to `int32` values
|
|
type Int32Rules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *int32 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *int32 `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *int32 `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *int32 `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *int32 `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []int32 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// Int64Rules describes the constraints applied to `int64` values
|
|
type Int64Rules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *int64 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *int64 `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *int64 `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *int64 `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *int64 `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []int64 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// UInt32Rules describes the constraints applied to `uint32` values
|
|
type UInt32Rules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *uint32 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *uint32 `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *uint32 `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *uint32 `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *uint32 `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []uint32 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// UInt64Rules describes the constraints applied to `uint64` values
|
|
type UInt64Rules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *uint64 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *uint64 `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *uint64 `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *uint64 `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *uint64 `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []uint64 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// SInt32Rules describes the constraints applied to `sint32` values
|
|
type SInt32Rules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *int32 `protobuf:"zigzag32,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *int32 `protobuf:"zigzag32,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *int32 `protobuf:"zigzag32,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *int32 `protobuf:"zigzag32,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *int32 `protobuf:"zigzag32,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []int32 `protobuf:"zigzag32,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// SInt64Rules describes the constraints applied to `sint64` values
|
|
type SInt64Rules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *int64 `protobuf:"zigzag64,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *int64 `protobuf:"zigzag64,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *int64 `protobuf:"zigzag64,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *int64 `protobuf:"zigzag64,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *int64 `protobuf:"zigzag64,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []int64 `protobuf:"zigzag64,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// Fixed32Rules describes the constraints applied to `fixed32` values
|
|
type Fixed32Rules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *uint32 `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *uint32 `protobuf:"fixed32,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *uint32 `protobuf:"fixed32,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *uint32 `protobuf:"fixed32,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *uint32 `protobuf:"fixed32,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []uint32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// Fixed64Rules describes the constraints applied to `fixed64` values
|
|
type Fixed64Rules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *uint64 `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *uint64 `protobuf:"fixed64,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *uint64 `protobuf:"fixed64,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *uint64 `protobuf:"fixed64,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *uint64 `protobuf:"fixed64,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []uint64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// SFixed32Rules describes the constraints applied to `sfixed32` values
|
|
type SFixed32Rules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *int32 `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *int32 `protobuf:"fixed32,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *int32 `protobuf:"fixed32,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *int32 `protobuf:"fixed32,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *int32 `protobuf:"fixed32,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []int32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// SFixed64Rules describes the constraints applied to `sfixed64` values
|
|
type SFixed64Rules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *int64 `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *int64 `protobuf:"fixed64,2,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than or equal to the
|
|
// specified value, inclusive
|
|
Lte *int64 `protobuf:"fixed64,3,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive. If the value of Gt is larger than a specified Lt or Lte, the
|
|
// range is reversed.
|
|
Gt *int64 `protobuf:"fixed64,4,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than or equal to the
|
|
// specified value, inclusive. If the value of Gte is larger than a
|
|
// specified Lt or Lte, the range is reversed.
|
|
Gte *int64 `protobuf:"fixed64,5,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []int64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// BoolRules describes the constraints applied to `bool` values
|
|
type BoolRules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// StringRules describe the constraints applied to `string` values
|
|
type StringRules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *string `protobuf:"bytes,1,opt,name=const" json:"const,omitempty"`
|
|
// Len specifies that this field must be the specified number of
|
|
// characters (Unicode code points). Note that the number of
|
|
// characters may differ from the number of bytes in the string.
|
|
Len *uint64 `protobuf:"varint,19,opt,name=len" json:"len,omitempty"`
|
|
// MinLen specifies that this field must be the specified number of
|
|
// characters (Unicode code points) at a minimum. Note that the number of
|
|
// characters may differ from the number of bytes in the string.
|
|
MinLen *uint64 `protobuf:"varint,2,opt,name=min_len,json=minLen" json:"min_len,omitempty"`
|
|
// MaxLen specifies that this field must be the specified number of
|
|
// characters (Unicode code points) at a maximum. Note that the number of
|
|
// characters may differ from the number of bytes in the string.
|
|
MaxLen *uint64 `protobuf:"varint,3,opt,name=max_len,json=maxLen" json:"max_len,omitempty"`
|
|
// LenBytes specifies that this field must be the specified number of bytes
|
|
// at a minimum
|
|
LenBytes *uint64 `protobuf:"varint,20,opt,name=len_bytes,json=lenBytes" json:"len_bytes,omitempty"`
|
|
// MinBytes specifies that this field must be the specified number of bytes
|
|
// at a minimum
|
|
MinBytes *uint64 `protobuf:"varint,4,opt,name=min_bytes,json=minBytes" json:"min_bytes,omitempty"`
|
|
// MaxBytes specifies that this field must be the specified number of bytes
|
|
// at a maximum
|
|
MaxBytes *uint64 `protobuf:"varint,5,opt,name=max_bytes,json=maxBytes" json:"max_bytes,omitempty"`
|
|
// Pattern specifes that this field must match against the specified
|
|
// regular expression (RE2 syntax). The included expression should elide
|
|
// any delimiters.
|
|
Pattern *string `protobuf:"bytes,6,opt,name=pattern" json:"pattern,omitempty"`
|
|
// Prefix specifies that this field must have the specified substring at
|
|
// the beginning of the string.
|
|
Prefix *string `protobuf:"bytes,7,opt,name=prefix" json:"prefix,omitempty"`
|
|
// Suffix specifies that this field must have the specified substring at
|
|
// the end of the string.
|
|
Suffix *string `protobuf:"bytes,8,opt,name=suffix" json:"suffix,omitempty"`
|
|
// Contains specifies that this field must have the specified substring
|
|
// anywhere in the string.
|
|
Contains *string `protobuf:"bytes,9,opt,name=contains" json:"contains,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []string `protobuf:"bytes,10,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
NotIn []string `protobuf:"bytes,11,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
|
|
// WellKnown rules provide advanced constraints against common string
|
|
// patterns
|
|
//
|
|
// Types that are valid to be assigned to WellKnown:
|
|
// *StringRules_Email
|
|
// *StringRules_Hostname
|
|
// *StringRules_Ip
|
|
// *StringRules_Ipv4
|
|
// *StringRules_Ipv6
|
|
// *StringRules_Uri
|
|
// *StringRules_UriRef
|
|
// *StringRules_Address
|
|
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_c8f5e113dd6422a8, []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
|
|
|
|
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
|
|
}
|
|
|
|
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"`
|
|
}
|
|
|
|
type StringRules_Address struct {
|
|
Address bool `protobuf:"varint,21,opt,name=address,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 (*StringRules_Address) isStringRules_WellKnown() {}
|
|
|
|
func (m *StringRules) GetWellKnown() isStringRules_WellKnown {
|
|
if m != nil {
|
|
return m.WellKnown
|
|
}
|
|
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
|
|
}
|
|
|
|
func (m *StringRules) GetAddress() bool {
|
|
if x, ok := m.GetWellKnown().(*StringRules_Address); ok {
|
|
return x.Address
|
|
}
|
|
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),
|
|
(*StringRules_Address)(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 *StringRules_Address:
|
|
t := uint64(0)
|
|
if x.Address {
|
|
t = 1
|
|
}
|
|
b.EncodeVarint(21<<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
|
|
case 21: // well_known.address
|
|
if wire != proto.WireVarint {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
x, err := b.DecodeVarint()
|
|
m.WellKnown = &StringRules_Address{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 *StringRules_Address:
|
|
n += 2 // tag and wire
|
|
n += 1
|
|
case nil:
|
|
default:
|
|
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
|
|
}
|
|
return n
|
|
}
|
|
|
|
// BytesRules describe the constraints applied to `bytes` values
|
|
type BytesRules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const []byte `protobuf:"bytes,1,opt,name=const" json:"const,omitempty"`
|
|
// Len specifies that this field must be the specified number of bytes
|
|
Len *uint64 `protobuf:"varint,13,opt,name=len" json:"len,omitempty"`
|
|
// MinLen specifies that this field must be the specified number of bytes
|
|
// at a minimum
|
|
MinLen *uint64 `protobuf:"varint,2,opt,name=min_len,json=minLen" json:"min_len,omitempty"`
|
|
// MaxLen specifies that this field must be the specified number of bytes
|
|
// at a maximum
|
|
MaxLen *uint64 `protobuf:"varint,3,opt,name=max_len,json=maxLen" json:"max_len,omitempty"`
|
|
// Pattern specifes that this field must match against the specified
|
|
// regular expression (RE2 syntax). The included expression should elide
|
|
// any delimiters.
|
|
Pattern *string `protobuf:"bytes,4,opt,name=pattern" json:"pattern,omitempty"`
|
|
// Prefix specifies that this field must have the specified bytes at the
|
|
// beginning of the string.
|
|
Prefix []byte `protobuf:"bytes,5,opt,name=prefix" json:"prefix,omitempty"`
|
|
// Suffix specifies that this field must have the specified bytes at the
|
|
// end of the string.
|
|
Suffix []byte `protobuf:"bytes,6,opt,name=suffix" json:"suffix,omitempty"`
|
|
// Contains specifies that this field must have the specified bytes
|
|
// anywhere in the string.
|
|
Contains []byte `protobuf:"bytes,7,opt,name=contains" json:"contains,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In [][]byte `protobuf:"bytes,8,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
NotIn [][]byte `protobuf:"bytes,9,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
|
|
// WellKnown rules provide advanced constraints against common byte
|
|
// patterns
|
|
//
|
|
// 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_c8f5e113dd6422a8, []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
|
|
|
|
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
|
|
}
|
|
|
|
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) 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
|
|
}
|
|
|
|
// EnumRules describe the constraints applied to enum values
|
|
type EnumRules struct {
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *int32 `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
|
|
// DefinedOnly specifies that this field must be only one of the defined
|
|
// values for this enum, failing on any undefined value.
|
|
DefinedOnly *bool `protobuf:"varint,2,opt,name=defined_only,json=definedOnly" json:"defined_only,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []int32 `protobuf:"varint,3,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// MessageRules describe the constraints applied to embedded message values.
|
|
// For message-type fields, validation is performed recursively.
|
|
type MessageRules struct {
|
|
// Skip specifies that the validation rules of this field should not be
|
|
// evaluated
|
|
Skip *bool `protobuf:"varint,1,opt,name=skip" json:"skip,omitempty"`
|
|
// Required specifies that this field must be set
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// RepeatedRules describe the constraints applied to `repeated` values
|
|
type RepeatedRules struct {
|
|
// MinItems specifies that this field must have the specified number of
|
|
// items at a minimum
|
|
MinItems *uint64 `protobuf:"varint,1,opt,name=min_items,json=minItems" json:"min_items,omitempty"`
|
|
// MaxItems specifies that this field must have the specified number of
|
|
// items at a maximum
|
|
MaxItems *uint64 `protobuf:"varint,2,opt,name=max_items,json=maxItems" json:"max_items,omitempty"`
|
|
// Unique specifies that all elements in this field must be unique. This
|
|
// contraint is only applicable to scalar and enum types (messages are not
|
|
// supported).
|
|
Unique *bool `protobuf:"varint,3,opt,name=unique" json:"unique,omitempty"`
|
|
// Items specifies the contraints to be applied to each item in the field.
|
|
// Repeated message fields will still execute validation against each item
|
|
// unless skip is specified here.
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// MapRules describe the constraints applied to `map` values
|
|
type MapRules struct {
|
|
// MinPairs specifies that this field must have the specified number of
|
|
// KVs at a minimum
|
|
MinPairs *uint64 `protobuf:"varint,1,opt,name=min_pairs,json=minPairs" json:"min_pairs,omitempty"`
|
|
// MaxPairs specifies that this field must have the specified number of
|
|
// KVs at a maximum
|
|
MaxPairs *uint64 `protobuf:"varint,2,opt,name=max_pairs,json=maxPairs" json:"max_pairs,omitempty"`
|
|
// NoSparse specifies values in this field cannot be unset. This only
|
|
// applies to map's with message value types.
|
|
NoSparse *bool `protobuf:"varint,3,opt,name=no_sparse,json=noSparse" json:"no_sparse,omitempty"`
|
|
// Keys specifies the constraints to be applied to each key in the field.
|
|
Keys *FieldRules `protobuf:"bytes,4,opt,name=keys" json:"keys,omitempty"`
|
|
// Values specifies the constraints to be applied to the value of each key
|
|
// in the field. Message values will still have their validations evaluated
|
|
// unless skip is specified here.
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// AnyRules describe constraints applied exclusively to the
|
|
// `google.protobuf.Any` well-known type
|
|
type AnyRules struct {
|
|
// Required specifies that this field must be set
|
|
Required *bool `protobuf:"varint,1,opt,name=required" json:"required,omitempty"`
|
|
// In specifies that this field's `type_url` must be equal to one of the
|
|
// specified values.
|
|
In []string `protobuf:"bytes,2,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field's `type_url` must not be equal to any of
|
|
// the specified values.
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// DurationRules describe the constraints applied exclusively to the
|
|
// `google.protobuf.Duration` well-known type
|
|
type DurationRules struct {
|
|
// Required specifies that this field must be set
|
|
Required *bool `protobuf:"varint,1,opt,name=required" json:"required,omitempty"`
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *duration.Duration `protobuf:"bytes,2,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *duration.Duration `protobuf:"bytes,3,opt,name=lt" json:"lt,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// inclusive
|
|
Lte *duration.Duration `protobuf:"bytes,4,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive
|
|
Gt *duration.Duration `protobuf:"bytes,5,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than the specified value,
|
|
// inclusive
|
|
Gte *duration.Duration `protobuf:"bytes,6,opt,name=gte" json:"gte,omitempty"`
|
|
// In specifies that this field must be equal to one of the specified
|
|
// values
|
|
In []*duration.Duration `protobuf:"bytes,7,rep,name=in" json:"in,omitempty"`
|
|
// NotIn specifies that this field cannot be equal to one of the specified
|
|
// values
|
|
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_c8f5e113dd6422a8, []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
|
|
}
|
|
|
|
// TimestampRules describe the constraints applied exclusively to the
|
|
// `google.protobuf.Timestamp` well-known type
|
|
type TimestampRules struct {
|
|
// Required specifies that this field must be set
|
|
Required *bool `protobuf:"varint,1,opt,name=required" json:"required,omitempty"`
|
|
// Const specifies that this field must be exactly the specified value
|
|
Const *timestamp.Timestamp `protobuf:"bytes,2,opt,name=const" json:"const,omitempty"`
|
|
// Lt specifies that this field must be less than the specified value,
|
|
// exclusive
|
|
Lt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=lt" json:"lt,omitempty"`
|
|
// Lte specifies that this field must be less than the specified value,
|
|
// inclusive
|
|
Lte *timestamp.Timestamp `protobuf:"bytes,4,opt,name=lte" json:"lte,omitempty"`
|
|
// Gt specifies that this field must be greater than the specified value,
|
|
// exclusive
|
|
Gt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=gt" json:"gt,omitempty"`
|
|
// Gte specifies that this field must be greater than the specified value,
|
|
// inclusive
|
|
Gte *timestamp.Timestamp `protobuf:"bytes,6,opt,name=gte" json:"gte,omitempty"`
|
|
// LtNow specifies that this must be less than the current time. LtNow
|
|
// can only be used with the Within rule.
|
|
LtNow *bool `protobuf:"varint,7,opt,name=lt_now,json=ltNow" json:"lt_now,omitempty"`
|
|
// GtNow specifies that this must be greater than the current time. GtNow
|
|
// can only be used with the Within rule.
|
|
GtNow *bool `protobuf:"varint,8,opt,name=gt_now,json=gtNow" json:"gt_now,omitempty"`
|
|
// Within specifies that this field must be within this duration of the
|
|
// current time. This constraint can be used alone or with the LtNow and
|
|
// GtNow rules.
|
|
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_c8f5e113dd6422a8, []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_c8f5e113dd6422a8) }
|
|
|
|
var fileDescriptor_validate_c8f5e113dd6422a8 = []byte{
|
|
// 1640 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x98, 0xcd, 0x6e, 0xdb, 0xc6,
|
|
0x16, 0xc7, 0xaf, 0xf8, 0x25, 0x6a, 0x2c, 0x45, 0xd2, 0xc4, 0x76, 0x18, 0xdf, 0x8f, 0x38, 0x5a,
|
|
0x5c, 0x38, 0xb9, 0x89, 0x9d, 0xeb, 0xb8, 0x42, 0x90, 0xa2, 0x05, 0x6a, 0xa4, 0x41, 0x83, 0x36,
|
|
0x4d, 0x40, 0x37, 0x9b, 0x6e, 0x04, 0xda, 0x1a, 0x29, 0x03, 0x53, 0x43, 0x86, 0xa4, 0x6c, 0xeb,
|
|
0x21, 0xd2, 0x76, 0xd7, 0xbe, 0x4a, 0x57, 0xdd, 0xf7, 0x4d, 0xba, 0xee, 0x0b, 0x14, 0xf3, 0xc5,
|
|
0x8f, 0x43, 0x5a, 0x5e, 0x74, 0xa7, 0x39, 0xe7, 0x7f, 0x66, 0x7e, 0xf8, 0x0f, 0x39, 0x73, 0x28,
|
|
0x74, 0xe7, 0x22, 0x08, 0xe9, 0x34, 0xc8, 0xc8, 0x81, 0xfe, 0xb1, 0x1f, 0x27, 0x51, 0x16, 0x61,
|
|
0x57, 0x8f, 0x77, 0x76, 0xe7, 0x51, 0x34, 0x0f, 0xc9, 0x81, 0x88, 0x9f, 0x2e, 0x67, 0x07, 0x53,
|
|
0x92, 0x9e, 0x25, 0x34, 0xce, 0xa2, 0x44, 0x6a, 0x77, 0xfe, 0x53, 0x53, 0x2c, 0x93, 0x20, 0xa3,
|
|
0x11, 0x53, 0xf9, 0x7b, 0x30, 0x9f, 0xd1, 0x05, 0x49, 0xb3, 0x60, 0x11, 0x4b, 0xc1, 0xe8, 0x77,
|
|
0x17, 0xa1, 0x97, 0x94, 0x84, 0x53, 0x7f, 0x19, 0x92, 0x14, 0x3f, 0x42, 0xf6, 0x2c, 0x8c, 0x82,
|
|
0xcc, 0x6b, 0xed, 0xb6, 0xf6, 0x36, 0x0e, 0x37, 0xf7, 0x73, 0xb6, 0x97, 0x3c, 0x2c, 0x44, 0x5f,
|
|
0xfd, 0xc3, 0x97, 0x22, 0x7c, 0x80, 0x9c, 0x69, 0xb4, 0x3c, 0x0d, 0x89, 0x67, 0x08, 0xf9, 0x56,
|
|
0x21, 0x7f, 0x21, 0xe2, 0x5a, 0xaf, 0x64, 0x7c, 0x7a, 0xca, 0xb2, 0xa7, 0x87, 0x9e, 0x09, 0xa7,
|
|
0x7f, 0xc5, 0xc3, 0xf9, 0xf4, 0x42, 0xa4, 0xd4, 0xe3, 0x23, 0xcf, 0x6a, 0x50, 0x8f, 0x8f, 0xca,
|
|
0xea, 0xf1, 0x11, 0x87, 0x59, 0xca, 0xc9, 0x6d, 0x08, 0xf3, 0xae, 0x32, 0xbb, 0x92, 0xe9, 0x82,
|
|
0xf1, 0x91, 0xe7, 0x34, 0x15, 0x14, 0x0b, 0x28, 0x19, 0x2f, 0x48, 0xe5, 0x0a, 0x6d, 0x58, 0x70,
|
|
0x52, 0x5d, 0x21, 0xcd, 0x57, 0x48, 0xe5, 0x0a, 0x6e, 0x53, 0x41, 0x69, 0x05, 0x29, 0xc3, 0x87,
|
|
0xa8, 0x3d, 0xa3, 0x57, 0x64, 0xfa, 0xf4, 0xd0, 0xeb, 0x88, 0x8a, 0xed, 0xd2, 0x06, 0xc8, 0x84,
|
|
0x2e, 0xd1, 0xc2, 0xbc, 0x66, 0x7c, 0xe4, 0xa1, 0xc6, 0x9a, 0x62, 0x19, 0x2d, 0xc4, 0x9f, 0x20,
|
|
0x37, 0xd5, 0x0b, 0x6d, 0x88, 0xa2, 0x3b, 0x25, 0x34, 0xb0, 0x52, 0x2e, 0x2d, 0xca, 0xc6, 0x47,
|
|
0x5e, 0xb7, 0xb9, 0xac, 0x58, 0x2c, 0x97, 0xe2, 0x07, 0xc8, 0x3a, 0x8d, 0xa2, 0xd0, 0xeb, 0x89,
|
|
0x92, 0xdb, 0x45, 0xc9, 0x71, 0x14, 0x85, 0x5a, 0x2e, 0x24, 0xc2, 0xb1, 0x2c, 0xa1, 0x6c, 0xee,
|
|
0xdd, 0xaa, 0x39, 0x26, 0xe2, 0x85, 0x63, 0x62, 0xc8, 0x9f, 0x91, 0xd3, 0x55, 0x46, 0x52, 0xaf,
|
|
0x0f, 0x9f, 0x91, 0x63, 0x1e, 0xce, 0x9f, 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, 0x6b, 0x99, 0xc8, 0x6d, 0x55, 0x42, 0xee, 0x4f, 0x42, 0x62, 0x12, 0x64, 0x64,
|
|
0xea, 0x61, 0xe8, 0x8f, 0xaf, 0x32, 0xb9, 0x3f, 0x5a, 0x8a, 0xff, 0x8b, 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, 0x2f,
|
|
0x54, 0x26, 0xc7, 0xd0, 0x52, 0xfc, 0x0c, 0x75, 0xf2, 0xd3, 0xc1, 0xdb, 0x16, 0x75, 0x5e, 0x51,
|
|
0xf7, 0x9d, 0x4e, 0xe9, 0xc2, 0x42, 0x7c, 0xec, 0x20, 0x2b, 0x5b, 0xc5, 0x64, 0xf4, 0xb1, 0x85,
|
|
0x50, 0x71, 0x4e, 0xe0, 0x4d, 0x64, 0x9f, 0x45, 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, 0x97, 0xde, 0xf0, 0x8d, 0xb9, 0x50, 0xcc, 0x33,
|
|
0x22, 0x5e, 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, 0xb1, 0xd1, 0x0f,
|
|
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, 0xbd, 0xb4, 0x55, 0x1e, 0xb3, 0xce, 0x63, 0x42, 0x1e, 0x13, 0xf2, 0x98, 0x90, 0xc7, 0x84,
|
|
0x3c, 0x66, 0x03, 0x8f, 0x59, 0xde, 0xb0, 0x77, 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, 0xb9, 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, 0xc7, 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, 0xa7, 0x16, 0xea, 0x9d, 0x5c, 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, 0x2f,
|
|
0x16, 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, 0x9f, 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, 0x16, 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, 0x5f, 0xc8, 0x7d, 0x1f, 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, 0xc5, 0x91, 0xe8, 0x09, 0x79, 0x4c, 0x8c, 0x54,
|
|
0x74, 0x2c, 0x9a, 0x3f, 0x1d, 0x1d, 0x63, 0x8c, 0xcc, 0x65, 0x42, 0x45, 0x8f, 0xc7, 0x83, 0x7c,
|
|
0x80, 0xef, 0xa2, 0xf6, 0x32, 0xa1, 0x93, 0x84, 0xcc, 0x44, 0x1b, 0xe7, 0x8a, 0x6f, 0x80, 0x84,
|
|
0xfa, 0x64, 0x86, 0x77, 0x50, 0x3b, 0x98, 0x4e, 0x13, 0x92, 0xa6, 0xa2, 0xb5, 0xe2, 0x29, 0x1d,
|
|
0x38, 0xee, 0x22, 0x74, 0x49, 0xc2, 0x70, 0x72, 0xce, 0xa2, 0x4b, 0x36, 0xfa, 0xcd, 0x40, 0xa8,
|
|
0xe8, 0x41, 0xab, 0x4f, 0x46, 0x17, 0x3c, 0x19, 0xbd, 0xbf, 0xf3, 0x64, 0x94, 0xb6, 0xd0, 0xba,
|
|
0x6e, 0x0b, 0x6d, 0xb1, 0x68, 0x7d, 0x0b, 0x1d, 0x19, 0x6f, 0xd8, 0xc2, 0xb6, 0xc8, 0xc0, 0x2d,
|
|
0x74, 0x77, 0xcd, 0xbd, 0x2e, 0xd8, 0xc2, 0x8e, 0x88, 0xa9, 0x2d, 0x94, 0x9b, 0x81, 0x1a, 0x36,
|
|
0x63, 0xa3, 0x71, 0x33, 0xba, 0xe5, 0xcd, 0x00, 0x0e, 0x9e, 0xa3, 0x4e, 0xde, 0x97, 0x5f, 0xd3,
|
|
0x2b, 0xdd, 0x47, 0xdd, 0x29, 0x99, 0x51, 0x46, 0xa6, 0x93, 0x88, 0x85, 0x2b, 0x61, 0x99, 0xeb,
|
|
0x6f, 0xa8, 0xd8, 0x1b, 0x16, 0xae, 0x14, 0xb8, 0xd9, 0xd0, 0x0a, 0x59, 0xe5, 0x56, 0xe8, 0x73,
|
|
0xd4, 0x2d, 0xb7, 0xf5, 0x18, 0x23, 0x2b, 0x3d, 0xa7, 0xb1, 0x7a, 0xdd, 0xc5, 0x6f, 0xee, 0x4f,
|
|
0x42, 0x3e, 0x2c, 0x69, 0x42, 0xa6, 0x6a, 0xa5, 0x7c, 0xcc, 0x5b, 0xa9, 0x5e, 0xa5, 0xc5, 0xd7,
|
|
0x2f, 0x25, 0xcd, 0xc8, 0x22, 0x55, 0xfd, 0x02, 0x7f, 0x29, 0x5f, 0xf1, 0xb1, 0x7e, 0x29, 0x65,
|
|
0xd2, 0xc8, 0x5f, 0x4a, 0x99, 0xdc, 0x46, 0xce, 0x92, 0xd1, 0x0f, 0x4b, 0x79, 0xac, 0xb9, 0xbe,
|
|
0x1a, 0xe1, 0x87, 0xc8, 0x96, 0x05, 0xb5, 0x0f, 0xe2, 0xe2, 0x13, 0xde, 0x97, 0x92, 0xd1, 0xaf,
|
|
0x2d, 0xe4, 0xea, 0x0f, 0x08, 0x8d, 0x12, 0x07, 0x34, 0x29, 0xa3, 0xbc, 0xe5, 0x63, 0x8d, 0x22,
|
|
0x93, 0x05, 0x4a, 0x9e, 0x64, 0xd1, 0x24, 0x8d, 0x83, 0x24, 0xd5, 0x34, 0x2e, 0x8b, 0x4e, 0xc4,
|
|
0x18, 0xef, 0x21, 0xeb, 0x9c, 0xac, 0xd6, 0xe3, 0x08, 0x05, 0x7e, 0x84, 0x9c, 0x8b, 0x20, 0x5c,
|
|
0xaa, 0x03, 0xe8, 0x3a, 0xad, 0xd2, 0x8c, 0x5e, 0x23, 0x57, 0x7f, 0xd3, 0x54, 0x3c, 0x6f, 0x55,
|
|
0x3d, 0x57, 0x5b, 0x6b, 0x34, 0x1c, 0x2b, 0x66, 0xe9, 0x58, 0x19, 0xfd, 0x61, 0xa0, 0x5e, 0xe5,
|
|
0xb3, 0x67, 0xed, 0xa4, 0x07, 0xfa, 0x41, 0x93, 0xff, 0x69, 0xdc, 0xdd, 0x97, 0x7f, 0xa1, 0xec,
|
|
0xeb, 0xbf, 0x50, 0x8a, 0x2f, 0x28, 0xf5, 0x0c, 0x3e, 0x10, 0x37, 0x92, 0x79, 0x93, 0x9a, 0x5f,
|
|
0x56, 0xff, 0x93, 0x97, 0x95, 0x75, 0x93, 0x56, 0xdc, 0x63, 0x0f, 0xc4, 0x3d, 0x66, 0xdf, 0x38,
|
|
0xef, 0x5c, 0xcc, 0xcb, 0xaf, 0x38, 0xe7, 0xc6, 0x79, 0xe7, 0x72, 0x5e, 0x75, 0xd3, 0xad, 0x9f,
|
|
0x97, 0x32, 0xfc, 0x24, 0x37, 0xd4, 0xbd, 0x49, 0xae, 0xbc, 0xfe, 0xd3, 0x40, 0xb7, 0xaa, 0x9f,
|
|
0x8a, 0x6b, 0xcd, 0x7e, 0x52, 0x35, 0x7b, 0xa7, 0x36, 0x7f, 0x31, 0x97, 0x72, 0xfb, 0x61, 0xc9,
|
|
0xed, 0x75, 0x72, 0x6e, 0xf7, 0xa3, 0xb2, 0xdd, 0xeb, 0xc4, 0xc2, 0xef, 0x87, 0x25, 0xbf, 0xd7,
|
|
0xce, 0x3c, 0x17, 0x33, 0x17, 0x86, 0xaf, 0x9d, 0x99, 0x3b, 0xbe, 0x85, 0x9c, 0x30, 0x9b, 0xb0,
|
|
0xe8, 0x52, 0x9c, 0xaa, 0xae, 0x6f, 0x87, 0xd9, 0xb7, 0xd1, 0x25, 0x0f, 0xcf, 0x65, 0xd8, 0x95,
|
|
0xe1, 0xb9, 0x08, 0xff, 0x1f, 0x39, 0x97, 0x34, 0x7b, 0x2f, 0x4e, 0xd6, 0x1b, 0xf6, 0x53, 0x09,
|
|
0x9f, 0x7f, 0x86, 0xdc, 0x29, 0x4d, 0x83, 0xd3, 0x90, 0x4c, 0xf1, 0xbd, 0x9a, 0x5c, 0x9d, 0x6b,
|
|
0x6f, 0x62, 0x5e, 0x93, 0x7a, 0x3f, 0x7f, 0x7c, 0x26, 0x77, 0x41, 0x97, 0x3c, 0xff, 0xb4, 0xd8,
|
|
0x21, 0xfc, 0xef, 0x5a, 0xf9, 0x1b, 0x46, 0xa2, 0x59, 0xad, 0x58, 0x17, 0x3c, 0xff, 0x1a, 0xd9,
|
|
0x89, 0xd8, 0xe7, 0x7a, 0xa5, 0x78, 0xb5, 0xab, 0x95, 0xd7, 0x9e, 0x5a, 0x62, 0x8e, 0xe3, 0xb7,
|
|
0x68, 0x87, 0x46, 0xfb, 0x84, 0x5d, 0x44, 0xab, 0x38, 0x89, 0xae, 0x56, 0xfb, 0xf1, 0xfc, 0x22,
|
|
0xd7, 0x7f, 0x7f, 0x38, 0xa7, 0xd9, 0xfb, 0xe5, 0xe9, 0xfe, 0x59, 0xb4, 0x38, 0x28, 0x34, 0xf2,
|
|
0xcf, 0xcd, 0xb3, 0xc7, 0x73, 0xc2, 0x1e, 0xd7, 0xfe, 0x53, 0xfd, 0x2b, 0x00, 0x00, 0xff, 0xff,
|
|
0xca, 0xcb, 0x15, 0xa8, 0x67, 0x15, 0x00, 0x00,
|
|
}
|