consul/vendor/github.com/envoyproxy/protoc-gen-validate/validate/validate.pb.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,
}