// Code generated by protoc-gen-go. DO NOT EDIT.
// source: validate/validate.proto

package validate // import "github.com/lyft/protoc-gen-validate/validate"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
import duration "github.com/golang/protobuf/ptypes/duration"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type FieldRules struct {
	// Types that are valid to be assigned to Type:
	//	*FieldRules_Float
	//	*FieldRules_Double
	//	*FieldRules_Int32
	//	*FieldRules_Int64
	//	*FieldRules_Uint32
	//	*FieldRules_Uint64
	//	*FieldRules_Sint32
	//	*FieldRules_Sint64
	//	*FieldRules_Fixed32
	//	*FieldRules_Fixed64
	//	*FieldRules_Sfixed32
	//	*FieldRules_Sfixed64
	//	*FieldRules_Bool
	//	*FieldRules_String_
	//	*FieldRules_Bytes
	//	*FieldRules_Enum
	//	*FieldRules_Message
	//	*FieldRules_Repeated
	//	*FieldRules_Map
	//	*FieldRules_Any
	//	*FieldRules_Duration
	//	*FieldRules_Timestamp
	Type                 isFieldRules_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *FieldRules) Reset()         { *m = FieldRules{} }
func (m *FieldRules) String() string { return proto.CompactTextString(m) }
func (*FieldRules) ProtoMessage()    {}
func (*FieldRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{0}
}
func (m *FieldRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FieldRules.Unmarshal(m, b)
}
func (m *FieldRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FieldRules.Marshal(b, m, deterministic)
}
func (dst *FieldRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FieldRules.Merge(dst, src)
}
func (m *FieldRules) XXX_Size() int {
	return xxx_messageInfo_FieldRules.Size(m)
}
func (m *FieldRules) XXX_DiscardUnknown() {
	xxx_messageInfo_FieldRules.DiscardUnknown(m)
}

var xxx_messageInfo_FieldRules proto.InternalMessageInfo

type isFieldRules_Type interface {
	isFieldRules_Type()
}

type FieldRules_Float struct {
	Float *FloatRules `protobuf:"bytes,1,opt,name=float,oneof"`
}
type FieldRules_Double struct {
	Double *DoubleRules `protobuf:"bytes,2,opt,name=double,oneof"`
}
type FieldRules_Int32 struct {
	Int32 *Int32Rules `protobuf:"bytes,3,opt,name=int32,oneof"`
}
type FieldRules_Int64 struct {
	Int64 *Int64Rules `protobuf:"bytes,4,opt,name=int64,oneof"`
}
type FieldRules_Uint32 struct {
	Uint32 *UInt32Rules `protobuf:"bytes,5,opt,name=uint32,oneof"`
}
type FieldRules_Uint64 struct {
	Uint64 *UInt64Rules `protobuf:"bytes,6,opt,name=uint64,oneof"`
}
type FieldRules_Sint32 struct {
	Sint32 *SInt32Rules `protobuf:"bytes,7,opt,name=sint32,oneof"`
}
type FieldRules_Sint64 struct {
	Sint64 *SInt64Rules `protobuf:"bytes,8,opt,name=sint64,oneof"`
}
type FieldRules_Fixed32 struct {
	Fixed32 *Fixed32Rules `protobuf:"bytes,9,opt,name=fixed32,oneof"`
}
type FieldRules_Fixed64 struct {
	Fixed64 *Fixed64Rules `protobuf:"bytes,10,opt,name=fixed64,oneof"`
}
type FieldRules_Sfixed32 struct {
	Sfixed32 *SFixed32Rules `protobuf:"bytes,11,opt,name=sfixed32,oneof"`
}
type FieldRules_Sfixed64 struct {
	Sfixed64 *SFixed64Rules `protobuf:"bytes,12,opt,name=sfixed64,oneof"`
}
type FieldRules_Bool struct {
	Bool *BoolRules `protobuf:"bytes,13,opt,name=bool,oneof"`
}
type FieldRules_String_ struct {
	String_ *StringRules `protobuf:"bytes,14,opt,name=string,oneof"`
}
type FieldRules_Bytes struct {
	Bytes *BytesRules `protobuf:"bytes,15,opt,name=bytes,oneof"`
}
type FieldRules_Enum struct {
	Enum *EnumRules `protobuf:"bytes,16,opt,name=enum,oneof"`
}
type FieldRules_Message struct {
	Message *MessageRules `protobuf:"bytes,17,opt,name=message,oneof"`
}
type FieldRules_Repeated struct {
	Repeated *RepeatedRules `protobuf:"bytes,18,opt,name=repeated,oneof"`
}
type FieldRules_Map struct {
	Map *MapRules `protobuf:"bytes,19,opt,name=map,oneof"`
}
type FieldRules_Any struct {
	Any *AnyRules `protobuf:"bytes,20,opt,name=any,oneof"`
}
type FieldRules_Duration struct {
	Duration *DurationRules `protobuf:"bytes,21,opt,name=duration,oneof"`
}
type FieldRules_Timestamp struct {
	Timestamp *TimestampRules `protobuf:"bytes,22,opt,name=timestamp,oneof"`
}

func (*FieldRules_Float) isFieldRules_Type()     {}
func (*FieldRules_Double) isFieldRules_Type()    {}
func (*FieldRules_Int32) isFieldRules_Type()     {}
func (*FieldRules_Int64) isFieldRules_Type()     {}
func (*FieldRules_Uint32) isFieldRules_Type()    {}
func (*FieldRules_Uint64) isFieldRules_Type()    {}
func (*FieldRules_Sint32) isFieldRules_Type()    {}
func (*FieldRules_Sint64) isFieldRules_Type()    {}
func (*FieldRules_Fixed32) isFieldRules_Type()   {}
func (*FieldRules_Fixed64) isFieldRules_Type()   {}
func (*FieldRules_Sfixed32) isFieldRules_Type()  {}
func (*FieldRules_Sfixed64) isFieldRules_Type()  {}
func (*FieldRules_Bool) isFieldRules_Type()      {}
func (*FieldRules_String_) isFieldRules_Type()   {}
func (*FieldRules_Bytes) isFieldRules_Type()     {}
func (*FieldRules_Enum) isFieldRules_Type()      {}
func (*FieldRules_Message) isFieldRules_Type()   {}
func (*FieldRules_Repeated) isFieldRules_Type()  {}
func (*FieldRules_Map) isFieldRules_Type()       {}
func (*FieldRules_Any) isFieldRules_Type()       {}
func (*FieldRules_Duration) isFieldRules_Type()  {}
func (*FieldRules_Timestamp) isFieldRules_Type() {}

func (m *FieldRules) GetType() isFieldRules_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *FieldRules) GetFloat() *FloatRules {
	if x, ok := m.GetType().(*FieldRules_Float); ok {
		return x.Float
	}
	return nil
}

func (m *FieldRules) GetDouble() *DoubleRules {
	if x, ok := m.GetType().(*FieldRules_Double); ok {
		return x.Double
	}
	return nil
}

func (m *FieldRules) GetInt32() *Int32Rules {
	if x, ok := m.GetType().(*FieldRules_Int32); ok {
		return x.Int32
	}
	return nil
}

func (m *FieldRules) GetInt64() *Int64Rules {
	if x, ok := m.GetType().(*FieldRules_Int64); ok {
		return x.Int64
	}
	return nil
}

func (m *FieldRules) GetUint32() *UInt32Rules {
	if x, ok := m.GetType().(*FieldRules_Uint32); ok {
		return x.Uint32
	}
	return nil
}

func (m *FieldRules) GetUint64() *UInt64Rules {
	if x, ok := m.GetType().(*FieldRules_Uint64); ok {
		return x.Uint64
	}
	return nil
}

func (m *FieldRules) GetSint32() *SInt32Rules {
	if x, ok := m.GetType().(*FieldRules_Sint32); ok {
		return x.Sint32
	}
	return nil
}

func (m *FieldRules) GetSint64() *SInt64Rules {
	if x, ok := m.GetType().(*FieldRules_Sint64); ok {
		return x.Sint64
	}
	return nil
}

func (m *FieldRules) GetFixed32() *Fixed32Rules {
	if x, ok := m.GetType().(*FieldRules_Fixed32); ok {
		return x.Fixed32
	}
	return nil
}

func (m *FieldRules) GetFixed64() *Fixed64Rules {
	if x, ok := m.GetType().(*FieldRules_Fixed64); ok {
		return x.Fixed64
	}
	return nil
}

func (m *FieldRules) GetSfixed32() *SFixed32Rules {
	if x, ok := m.GetType().(*FieldRules_Sfixed32); ok {
		return x.Sfixed32
	}
	return nil
}

func (m *FieldRules) GetSfixed64() *SFixed64Rules {
	if x, ok := m.GetType().(*FieldRules_Sfixed64); ok {
		return x.Sfixed64
	}
	return nil
}

func (m *FieldRules) GetBool() *BoolRules {
	if x, ok := m.GetType().(*FieldRules_Bool); ok {
		return x.Bool
	}
	return nil
}

func (m *FieldRules) GetString_() *StringRules {
	if x, ok := m.GetType().(*FieldRules_String_); ok {
		return x.String_
	}
	return nil
}

func (m *FieldRules) GetBytes() *BytesRules {
	if x, ok := m.GetType().(*FieldRules_Bytes); ok {
		return x.Bytes
	}
	return nil
}

func (m *FieldRules) GetEnum() *EnumRules {
	if x, ok := m.GetType().(*FieldRules_Enum); ok {
		return x.Enum
	}
	return nil
}

func (m *FieldRules) GetMessage() *MessageRules {
	if x, ok := m.GetType().(*FieldRules_Message); ok {
		return x.Message
	}
	return nil
}

func (m *FieldRules) GetRepeated() *RepeatedRules {
	if x, ok := m.GetType().(*FieldRules_Repeated); ok {
		return x.Repeated
	}
	return nil
}

func (m *FieldRules) GetMap() *MapRules {
	if x, ok := m.GetType().(*FieldRules_Map); ok {
		return x.Map
	}
	return nil
}

func (m *FieldRules) GetAny() *AnyRules {
	if x, ok := m.GetType().(*FieldRules_Any); ok {
		return x.Any
	}
	return nil
}

func (m *FieldRules) GetDuration() *DurationRules {
	if x, ok := m.GetType().(*FieldRules_Duration); ok {
		return x.Duration
	}
	return nil
}

func (m *FieldRules) GetTimestamp() *TimestampRules {
	if x, ok := m.GetType().(*FieldRules_Timestamp); ok {
		return x.Timestamp
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*FieldRules) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _FieldRules_OneofMarshaler, _FieldRules_OneofUnmarshaler, _FieldRules_OneofSizer, []interface{}{
		(*FieldRules_Float)(nil),
		(*FieldRules_Double)(nil),
		(*FieldRules_Int32)(nil),
		(*FieldRules_Int64)(nil),
		(*FieldRules_Uint32)(nil),
		(*FieldRules_Uint64)(nil),
		(*FieldRules_Sint32)(nil),
		(*FieldRules_Sint64)(nil),
		(*FieldRules_Fixed32)(nil),
		(*FieldRules_Fixed64)(nil),
		(*FieldRules_Sfixed32)(nil),
		(*FieldRules_Sfixed64)(nil),
		(*FieldRules_Bool)(nil),
		(*FieldRules_String_)(nil),
		(*FieldRules_Bytes)(nil),
		(*FieldRules_Enum)(nil),
		(*FieldRules_Message)(nil),
		(*FieldRules_Repeated)(nil),
		(*FieldRules_Map)(nil),
		(*FieldRules_Any)(nil),
		(*FieldRules_Duration)(nil),
		(*FieldRules_Timestamp)(nil),
	}
}

func _FieldRules_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*FieldRules)
	// type
	switch x := m.Type.(type) {
	case *FieldRules_Float:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Float); err != nil {
			return err
		}
	case *FieldRules_Double:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Double); err != nil {
			return err
		}
	case *FieldRules_Int32:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Int32); err != nil {
			return err
		}
	case *FieldRules_Int64:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Int64); err != nil {
			return err
		}
	case *FieldRules_Uint32:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Uint32); err != nil {
			return err
		}
	case *FieldRules_Uint64:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Uint64); err != nil {
			return err
		}
	case *FieldRules_Sint32:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Sint32); err != nil {
			return err
		}
	case *FieldRules_Sint64:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Sint64); err != nil {
			return err
		}
	case *FieldRules_Fixed32:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Fixed32); err != nil {
			return err
		}
	case *FieldRules_Fixed64:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Fixed64); err != nil {
			return err
		}
	case *FieldRules_Sfixed32:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Sfixed32); err != nil {
			return err
		}
	case *FieldRules_Sfixed64:
		b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Sfixed64); err != nil {
			return err
		}
	case *FieldRules_Bool:
		b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Bool); err != nil {
			return err
		}
	case *FieldRules_String_:
		b.EncodeVarint(14<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.String_); err != nil {
			return err
		}
	case *FieldRules_Bytes:
		b.EncodeVarint(15<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Bytes); err != nil {
			return err
		}
	case *FieldRules_Enum:
		b.EncodeVarint(16<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Enum); err != nil {
			return err
		}
	case *FieldRules_Message:
		b.EncodeVarint(17<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Message); err != nil {
			return err
		}
	case *FieldRules_Repeated:
		b.EncodeVarint(18<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Repeated); err != nil {
			return err
		}
	case *FieldRules_Map:
		b.EncodeVarint(19<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Map); err != nil {
			return err
		}
	case *FieldRules_Any:
		b.EncodeVarint(20<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Any); err != nil {
			return err
		}
	case *FieldRules_Duration:
		b.EncodeVarint(21<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Duration); err != nil {
			return err
		}
	case *FieldRules_Timestamp:
		b.EncodeVarint(22<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Timestamp); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("FieldRules.Type has unexpected type %T", x)
	}
	return nil
}

func _FieldRules_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*FieldRules)
	switch tag {
	case 1: // type.float
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(FloatRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Float{msg}
		return true, err
	case 2: // type.double
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DoubleRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Double{msg}
		return true, err
	case 3: // type.int32
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Int32Rules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Int32{msg}
		return true, err
	case 4: // type.int64
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Int64Rules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Int64{msg}
		return true, err
	case 5: // type.uint32
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(UInt32Rules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Uint32{msg}
		return true, err
	case 6: // type.uint64
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(UInt64Rules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Uint64{msg}
		return true, err
	case 7: // type.sint32
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SInt32Rules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Sint32{msg}
		return true, err
	case 8: // type.sint64
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SInt64Rules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Sint64{msg}
		return true, err
	case 9: // type.fixed32
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Fixed32Rules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Fixed32{msg}
		return true, err
	case 10: // type.fixed64
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Fixed64Rules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Fixed64{msg}
		return true, err
	case 11: // type.sfixed32
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SFixed32Rules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Sfixed32{msg}
		return true, err
	case 12: // type.sfixed64
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SFixed64Rules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Sfixed64{msg}
		return true, err
	case 13: // type.bool
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(BoolRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Bool{msg}
		return true, err
	case 14: // type.string
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StringRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_String_{msg}
		return true, err
	case 15: // type.bytes
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(BytesRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Bytes{msg}
		return true, err
	case 16: // type.enum
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(EnumRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Enum{msg}
		return true, err
	case 17: // type.message
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MessageRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Message{msg}
		return true, err
	case 18: // type.repeated
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RepeatedRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Repeated{msg}
		return true, err
	case 19: // type.map
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MapRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Map{msg}
		return true, err
	case 20: // type.any
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(AnyRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Any{msg}
		return true, err
	case 21: // type.duration
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DurationRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Duration{msg}
		return true, err
	case 22: // type.timestamp
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TimestampRules)
		err := b.DecodeMessage(msg)
		m.Type = &FieldRules_Timestamp{msg}
		return true, err
	default:
		return false, nil
	}
}

func _FieldRules_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*FieldRules)
	// type
	switch x := m.Type.(type) {
	case *FieldRules_Float:
		s := proto.Size(x.Float)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Double:
		s := proto.Size(x.Double)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Int32:
		s := proto.Size(x.Int32)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Int64:
		s := proto.Size(x.Int64)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Uint32:
		s := proto.Size(x.Uint32)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Uint64:
		s := proto.Size(x.Uint64)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Sint32:
		s := proto.Size(x.Sint32)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Sint64:
		s := proto.Size(x.Sint64)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Fixed32:
		s := proto.Size(x.Fixed32)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Fixed64:
		s := proto.Size(x.Fixed64)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Sfixed32:
		s := proto.Size(x.Sfixed32)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Sfixed64:
		s := proto.Size(x.Sfixed64)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Bool:
		s := proto.Size(x.Bool)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_String_:
		s := proto.Size(x.String_)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Bytes:
		s := proto.Size(x.Bytes)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Enum:
		s := proto.Size(x.Enum)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Message:
		s := proto.Size(x.Message)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Repeated:
		s := proto.Size(x.Repeated)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Map:
		s := proto.Size(x.Map)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Any:
		s := proto.Size(x.Any)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Duration:
		s := proto.Size(x.Duration)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldRules_Timestamp:
		s := proto.Size(x.Timestamp)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type FloatRules struct {
	Const                *float32  `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
	Lt                   *float32  `protobuf:"fixed32,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *float32  `protobuf:"fixed32,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *float32  `protobuf:"fixed32,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *float32  `protobuf:"fixed32,5,opt,name=gte" json:"gte,omitempty"`
	In                   []float32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
	NotIn                []float32 `protobuf:"fixed32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *FloatRules) Reset()         { *m = FloatRules{} }
func (m *FloatRules) String() string { return proto.CompactTextString(m) }
func (*FloatRules) ProtoMessage()    {}
func (*FloatRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{1}
}
func (m *FloatRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FloatRules.Unmarshal(m, b)
}
func (m *FloatRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FloatRules.Marshal(b, m, deterministic)
}
func (dst *FloatRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FloatRules.Merge(dst, src)
}
func (m *FloatRules) XXX_Size() int {
	return xxx_messageInfo_FloatRules.Size(m)
}
func (m *FloatRules) XXX_DiscardUnknown() {
	xxx_messageInfo_FloatRules.DiscardUnknown(m)
}

var xxx_messageInfo_FloatRules proto.InternalMessageInfo

func (m *FloatRules) GetConst() float32 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *FloatRules) GetLt() float32 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *FloatRules) GetLte() float32 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *FloatRules) GetGt() float32 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *FloatRules) GetGte() float32 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *FloatRules) GetIn() []float32 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *FloatRules) GetNotIn() []float32 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type DoubleRules struct {
	Const                *float64  `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
	Lt                   *float64  `protobuf:"fixed64,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *float64  `protobuf:"fixed64,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *float64  `protobuf:"fixed64,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *float64  `protobuf:"fixed64,5,opt,name=gte" json:"gte,omitempty"`
	In                   []float64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
	NotIn                []float64 `protobuf:"fixed64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *DoubleRules) Reset()         { *m = DoubleRules{} }
func (m *DoubleRules) String() string { return proto.CompactTextString(m) }
func (*DoubleRules) ProtoMessage()    {}
func (*DoubleRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{2}
}
func (m *DoubleRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DoubleRules.Unmarshal(m, b)
}
func (m *DoubleRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DoubleRules.Marshal(b, m, deterministic)
}
func (dst *DoubleRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DoubleRules.Merge(dst, src)
}
func (m *DoubleRules) XXX_Size() int {
	return xxx_messageInfo_DoubleRules.Size(m)
}
func (m *DoubleRules) XXX_DiscardUnknown() {
	xxx_messageInfo_DoubleRules.DiscardUnknown(m)
}

var xxx_messageInfo_DoubleRules proto.InternalMessageInfo

func (m *DoubleRules) GetConst() float64 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *DoubleRules) GetLt() float64 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *DoubleRules) GetLte() float64 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *DoubleRules) GetGt() float64 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *DoubleRules) GetGte() float64 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *DoubleRules) GetIn() []float64 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *DoubleRules) GetNotIn() []float64 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type Int32Rules struct {
	Const                *int32   `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
	Lt                   *int32   `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *int32   `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *int32   `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *int32   `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
	In                   []int32  `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
	NotIn                []int32  `protobuf:"varint,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Int32Rules) Reset()         { *m = Int32Rules{} }
func (m *Int32Rules) String() string { return proto.CompactTextString(m) }
func (*Int32Rules) ProtoMessage()    {}
func (*Int32Rules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{3}
}
func (m *Int32Rules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Int32Rules.Unmarshal(m, b)
}
func (m *Int32Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Int32Rules.Marshal(b, m, deterministic)
}
func (dst *Int32Rules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Int32Rules.Merge(dst, src)
}
func (m *Int32Rules) XXX_Size() int {
	return xxx_messageInfo_Int32Rules.Size(m)
}
func (m *Int32Rules) XXX_DiscardUnknown() {
	xxx_messageInfo_Int32Rules.DiscardUnknown(m)
}

var xxx_messageInfo_Int32Rules proto.InternalMessageInfo

func (m *Int32Rules) GetConst() int32 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *Int32Rules) GetLt() int32 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *Int32Rules) GetLte() int32 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *Int32Rules) GetGt() int32 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *Int32Rules) GetGte() int32 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *Int32Rules) GetIn() []int32 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *Int32Rules) GetNotIn() []int32 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type Int64Rules struct {
	Const                *int64   `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
	Lt                   *int64   `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *int64   `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *int64   `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *int64   `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
	In                   []int64  `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
	NotIn                []int64  `protobuf:"varint,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Int64Rules) Reset()         { *m = Int64Rules{} }
func (m *Int64Rules) String() string { return proto.CompactTextString(m) }
func (*Int64Rules) ProtoMessage()    {}
func (*Int64Rules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{4}
}
func (m *Int64Rules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Int64Rules.Unmarshal(m, b)
}
func (m *Int64Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Int64Rules.Marshal(b, m, deterministic)
}
func (dst *Int64Rules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Int64Rules.Merge(dst, src)
}
func (m *Int64Rules) XXX_Size() int {
	return xxx_messageInfo_Int64Rules.Size(m)
}
func (m *Int64Rules) XXX_DiscardUnknown() {
	xxx_messageInfo_Int64Rules.DiscardUnknown(m)
}

var xxx_messageInfo_Int64Rules proto.InternalMessageInfo

func (m *Int64Rules) GetConst() int64 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *Int64Rules) GetLt() int64 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *Int64Rules) GetLte() int64 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *Int64Rules) GetGt() int64 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *Int64Rules) GetGte() int64 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *Int64Rules) GetIn() []int64 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *Int64Rules) GetNotIn() []int64 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type UInt32Rules struct {
	Const                *uint32  `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
	Lt                   *uint32  `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *uint32  `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *uint32  `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *uint32  `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
	In                   []uint32 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
	NotIn                []uint32 `protobuf:"varint,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UInt32Rules) Reset()         { *m = UInt32Rules{} }
func (m *UInt32Rules) String() string { return proto.CompactTextString(m) }
func (*UInt32Rules) ProtoMessage()    {}
func (*UInt32Rules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{5}
}
func (m *UInt32Rules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UInt32Rules.Unmarshal(m, b)
}
func (m *UInt32Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UInt32Rules.Marshal(b, m, deterministic)
}
func (dst *UInt32Rules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UInt32Rules.Merge(dst, src)
}
func (m *UInt32Rules) XXX_Size() int {
	return xxx_messageInfo_UInt32Rules.Size(m)
}
func (m *UInt32Rules) XXX_DiscardUnknown() {
	xxx_messageInfo_UInt32Rules.DiscardUnknown(m)
}

var xxx_messageInfo_UInt32Rules proto.InternalMessageInfo

func (m *UInt32Rules) GetConst() uint32 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *UInt32Rules) GetLt() uint32 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *UInt32Rules) GetLte() uint32 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *UInt32Rules) GetGt() uint32 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *UInt32Rules) GetGte() uint32 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *UInt32Rules) GetIn() []uint32 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *UInt32Rules) GetNotIn() []uint32 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type UInt64Rules struct {
	Const                *uint64  `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
	Lt                   *uint64  `protobuf:"varint,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *uint64  `protobuf:"varint,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *uint64  `protobuf:"varint,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *uint64  `protobuf:"varint,5,opt,name=gte" json:"gte,omitempty"`
	In                   []uint64 `protobuf:"varint,6,rep,name=in" json:"in,omitempty"`
	NotIn                []uint64 `protobuf:"varint,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UInt64Rules) Reset()         { *m = UInt64Rules{} }
func (m *UInt64Rules) String() string { return proto.CompactTextString(m) }
func (*UInt64Rules) ProtoMessage()    {}
func (*UInt64Rules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{6}
}
func (m *UInt64Rules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UInt64Rules.Unmarshal(m, b)
}
func (m *UInt64Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UInt64Rules.Marshal(b, m, deterministic)
}
func (dst *UInt64Rules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UInt64Rules.Merge(dst, src)
}
func (m *UInt64Rules) XXX_Size() int {
	return xxx_messageInfo_UInt64Rules.Size(m)
}
func (m *UInt64Rules) XXX_DiscardUnknown() {
	xxx_messageInfo_UInt64Rules.DiscardUnknown(m)
}

var xxx_messageInfo_UInt64Rules proto.InternalMessageInfo

func (m *UInt64Rules) GetConst() uint64 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *UInt64Rules) GetLt() uint64 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *UInt64Rules) GetLte() uint64 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *UInt64Rules) GetGt() uint64 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *UInt64Rules) GetGte() uint64 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *UInt64Rules) GetIn() []uint64 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *UInt64Rules) GetNotIn() []uint64 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type SInt32Rules struct {
	Const                *int32   `protobuf:"zigzag32,1,opt,name=const" json:"const,omitempty"`
	Lt                   *int32   `protobuf:"zigzag32,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *int32   `protobuf:"zigzag32,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *int32   `protobuf:"zigzag32,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *int32   `protobuf:"zigzag32,5,opt,name=gte" json:"gte,omitempty"`
	In                   []int32  `protobuf:"zigzag32,6,rep,name=in" json:"in,omitempty"`
	NotIn                []int32  `protobuf:"zigzag32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SInt32Rules) Reset()         { *m = SInt32Rules{} }
func (m *SInt32Rules) String() string { return proto.CompactTextString(m) }
func (*SInt32Rules) ProtoMessage()    {}
func (*SInt32Rules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{7}
}
func (m *SInt32Rules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SInt32Rules.Unmarshal(m, b)
}
func (m *SInt32Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SInt32Rules.Marshal(b, m, deterministic)
}
func (dst *SInt32Rules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SInt32Rules.Merge(dst, src)
}
func (m *SInt32Rules) XXX_Size() int {
	return xxx_messageInfo_SInt32Rules.Size(m)
}
func (m *SInt32Rules) XXX_DiscardUnknown() {
	xxx_messageInfo_SInt32Rules.DiscardUnknown(m)
}

var xxx_messageInfo_SInt32Rules proto.InternalMessageInfo

func (m *SInt32Rules) GetConst() int32 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *SInt32Rules) GetLt() int32 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *SInt32Rules) GetLte() int32 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *SInt32Rules) GetGt() int32 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *SInt32Rules) GetGte() int32 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *SInt32Rules) GetIn() []int32 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *SInt32Rules) GetNotIn() []int32 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type SInt64Rules struct {
	Const                *int64   `protobuf:"zigzag64,1,opt,name=const" json:"const,omitempty"`
	Lt                   *int64   `protobuf:"zigzag64,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *int64   `protobuf:"zigzag64,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *int64   `protobuf:"zigzag64,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *int64   `protobuf:"zigzag64,5,opt,name=gte" json:"gte,omitempty"`
	In                   []int64  `protobuf:"zigzag64,6,rep,name=in" json:"in,omitempty"`
	NotIn                []int64  `protobuf:"zigzag64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SInt64Rules) Reset()         { *m = SInt64Rules{} }
func (m *SInt64Rules) String() string { return proto.CompactTextString(m) }
func (*SInt64Rules) ProtoMessage()    {}
func (*SInt64Rules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{8}
}
func (m *SInt64Rules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SInt64Rules.Unmarshal(m, b)
}
func (m *SInt64Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SInt64Rules.Marshal(b, m, deterministic)
}
func (dst *SInt64Rules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SInt64Rules.Merge(dst, src)
}
func (m *SInt64Rules) XXX_Size() int {
	return xxx_messageInfo_SInt64Rules.Size(m)
}
func (m *SInt64Rules) XXX_DiscardUnknown() {
	xxx_messageInfo_SInt64Rules.DiscardUnknown(m)
}

var xxx_messageInfo_SInt64Rules proto.InternalMessageInfo

func (m *SInt64Rules) GetConst() int64 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *SInt64Rules) GetLt() int64 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *SInt64Rules) GetLte() int64 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *SInt64Rules) GetGt() int64 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *SInt64Rules) GetGte() int64 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *SInt64Rules) GetIn() []int64 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *SInt64Rules) GetNotIn() []int64 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type Fixed32Rules struct {
	Const                *uint32  `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
	Lt                   *uint32  `protobuf:"fixed32,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *uint32  `protobuf:"fixed32,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *uint32  `protobuf:"fixed32,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *uint32  `protobuf:"fixed32,5,opt,name=gte" json:"gte,omitempty"`
	In                   []uint32 `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
	NotIn                []uint32 `protobuf:"fixed32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Fixed32Rules) Reset()         { *m = Fixed32Rules{} }
func (m *Fixed32Rules) String() string { return proto.CompactTextString(m) }
func (*Fixed32Rules) ProtoMessage()    {}
func (*Fixed32Rules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{9}
}
func (m *Fixed32Rules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Fixed32Rules.Unmarshal(m, b)
}
func (m *Fixed32Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Fixed32Rules.Marshal(b, m, deterministic)
}
func (dst *Fixed32Rules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Fixed32Rules.Merge(dst, src)
}
func (m *Fixed32Rules) XXX_Size() int {
	return xxx_messageInfo_Fixed32Rules.Size(m)
}
func (m *Fixed32Rules) XXX_DiscardUnknown() {
	xxx_messageInfo_Fixed32Rules.DiscardUnknown(m)
}

var xxx_messageInfo_Fixed32Rules proto.InternalMessageInfo

func (m *Fixed32Rules) GetConst() uint32 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *Fixed32Rules) GetLt() uint32 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *Fixed32Rules) GetLte() uint32 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *Fixed32Rules) GetGt() uint32 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *Fixed32Rules) GetGte() uint32 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *Fixed32Rules) GetIn() []uint32 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *Fixed32Rules) GetNotIn() []uint32 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type Fixed64Rules struct {
	Const                *uint64  `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
	Lt                   *uint64  `protobuf:"fixed64,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *uint64  `protobuf:"fixed64,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *uint64  `protobuf:"fixed64,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *uint64  `protobuf:"fixed64,5,opt,name=gte" json:"gte,omitempty"`
	In                   []uint64 `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
	NotIn                []uint64 `protobuf:"fixed64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Fixed64Rules) Reset()         { *m = Fixed64Rules{} }
func (m *Fixed64Rules) String() string { return proto.CompactTextString(m) }
func (*Fixed64Rules) ProtoMessage()    {}
func (*Fixed64Rules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{10}
}
func (m *Fixed64Rules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Fixed64Rules.Unmarshal(m, b)
}
func (m *Fixed64Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Fixed64Rules.Marshal(b, m, deterministic)
}
func (dst *Fixed64Rules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Fixed64Rules.Merge(dst, src)
}
func (m *Fixed64Rules) XXX_Size() int {
	return xxx_messageInfo_Fixed64Rules.Size(m)
}
func (m *Fixed64Rules) XXX_DiscardUnknown() {
	xxx_messageInfo_Fixed64Rules.DiscardUnknown(m)
}

var xxx_messageInfo_Fixed64Rules proto.InternalMessageInfo

func (m *Fixed64Rules) GetConst() uint64 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *Fixed64Rules) GetLt() uint64 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *Fixed64Rules) GetLte() uint64 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *Fixed64Rules) GetGt() uint64 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *Fixed64Rules) GetGte() uint64 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *Fixed64Rules) GetIn() []uint64 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *Fixed64Rules) GetNotIn() []uint64 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type SFixed32Rules struct {
	Const                *int32   `protobuf:"fixed32,1,opt,name=const" json:"const,omitempty"`
	Lt                   *int32   `protobuf:"fixed32,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *int32   `protobuf:"fixed32,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *int32   `protobuf:"fixed32,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *int32   `protobuf:"fixed32,5,opt,name=gte" json:"gte,omitempty"`
	In                   []int32  `protobuf:"fixed32,6,rep,name=in" json:"in,omitempty"`
	NotIn                []int32  `protobuf:"fixed32,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SFixed32Rules) Reset()         { *m = SFixed32Rules{} }
func (m *SFixed32Rules) String() string { return proto.CompactTextString(m) }
func (*SFixed32Rules) ProtoMessage()    {}
func (*SFixed32Rules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{11}
}
func (m *SFixed32Rules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SFixed32Rules.Unmarshal(m, b)
}
func (m *SFixed32Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SFixed32Rules.Marshal(b, m, deterministic)
}
func (dst *SFixed32Rules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SFixed32Rules.Merge(dst, src)
}
func (m *SFixed32Rules) XXX_Size() int {
	return xxx_messageInfo_SFixed32Rules.Size(m)
}
func (m *SFixed32Rules) XXX_DiscardUnknown() {
	xxx_messageInfo_SFixed32Rules.DiscardUnknown(m)
}

var xxx_messageInfo_SFixed32Rules proto.InternalMessageInfo

func (m *SFixed32Rules) GetConst() int32 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *SFixed32Rules) GetLt() int32 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *SFixed32Rules) GetLte() int32 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *SFixed32Rules) GetGt() int32 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *SFixed32Rules) GetGte() int32 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *SFixed32Rules) GetIn() []int32 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *SFixed32Rules) GetNotIn() []int32 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type SFixed64Rules struct {
	Const                *int64   `protobuf:"fixed64,1,opt,name=const" json:"const,omitempty"`
	Lt                   *int64   `protobuf:"fixed64,2,opt,name=lt" json:"lt,omitempty"`
	Lte                  *int64   `protobuf:"fixed64,3,opt,name=lte" json:"lte,omitempty"`
	Gt                   *int64   `protobuf:"fixed64,4,opt,name=gt" json:"gt,omitempty"`
	Gte                  *int64   `protobuf:"fixed64,5,opt,name=gte" json:"gte,omitempty"`
	In                   []int64  `protobuf:"fixed64,6,rep,name=in" json:"in,omitempty"`
	NotIn                []int64  `protobuf:"fixed64,7,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SFixed64Rules) Reset()         { *m = SFixed64Rules{} }
func (m *SFixed64Rules) String() string { return proto.CompactTextString(m) }
func (*SFixed64Rules) ProtoMessage()    {}
func (*SFixed64Rules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{12}
}
func (m *SFixed64Rules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SFixed64Rules.Unmarshal(m, b)
}
func (m *SFixed64Rules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SFixed64Rules.Marshal(b, m, deterministic)
}
func (dst *SFixed64Rules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SFixed64Rules.Merge(dst, src)
}
func (m *SFixed64Rules) XXX_Size() int {
	return xxx_messageInfo_SFixed64Rules.Size(m)
}
func (m *SFixed64Rules) XXX_DiscardUnknown() {
	xxx_messageInfo_SFixed64Rules.DiscardUnknown(m)
}

var xxx_messageInfo_SFixed64Rules proto.InternalMessageInfo

func (m *SFixed64Rules) GetConst() int64 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *SFixed64Rules) GetLt() int64 {
	if m != nil && m.Lt != nil {
		return *m.Lt
	}
	return 0
}

func (m *SFixed64Rules) GetLte() int64 {
	if m != nil && m.Lte != nil {
		return *m.Lte
	}
	return 0
}

func (m *SFixed64Rules) GetGt() int64 {
	if m != nil && m.Gt != nil {
		return *m.Gt
	}
	return 0
}

func (m *SFixed64Rules) GetGte() int64 {
	if m != nil && m.Gte != nil {
		return *m.Gte
	}
	return 0
}

func (m *SFixed64Rules) GetIn() []int64 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *SFixed64Rules) GetNotIn() []int64 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type BoolRules struct {
	Const                *bool    `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BoolRules) Reset()         { *m = BoolRules{} }
func (m *BoolRules) String() string { return proto.CompactTextString(m) }
func (*BoolRules) ProtoMessage()    {}
func (*BoolRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{13}
}
func (m *BoolRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BoolRules.Unmarshal(m, b)
}
func (m *BoolRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BoolRules.Marshal(b, m, deterministic)
}
func (dst *BoolRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BoolRules.Merge(dst, src)
}
func (m *BoolRules) XXX_Size() int {
	return xxx_messageInfo_BoolRules.Size(m)
}
func (m *BoolRules) XXX_DiscardUnknown() {
	xxx_messageInfo_BoolRules.DiscardUnknown(m)
}

var xxx_messageInfo_BoolRules proto.InternalMessageInfo

func (m *BoolRules) GetConst() bool {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return false
}

type StringRules struct {
	Const    *string  `protobuf:"bytes,1,opt,name=const" json:"const,omitempty"`
	Len      *uint64  `protobuf:"varint,19,opt,name=len" json:"len,omitempty"`
	MinLen   *uint64  `protobuf:"varint,2,opt,name=min_len,json=minLen" json:"min_len,omitempty"`
	MaxLen   *uint64  `protobuf:"varint,3,opt,name=max_len,json=maxLen" json:"max_len,omitempty"`
	LenBytes *uint64  `protobuf:"varint,20,opt,name=len_bytes,json=lenBytes" json:"len_bytes,omitempty"`
	MinBytes *uint64  `protobuf:"varint,4,opt,name=min_bytes,json=minBytes" json:"min_bytes,omitempty"`
	MaxBytes *uint64  `protobuf:"varint,5,opt,name=max_bytes,json=maxBytes" json:"max_bytes,omitempty"`
	Pattern  *string  `protobuf:"bytes,6,opt,name=pattern" json:"pattern,omitempty"`
	Prefix   *string  `protobuf:"bytes,7,opt,name=prefix" json:"prefix,omitempty"`
	Suffix   *string  `protobuf:"bytes,8,opt,name=suffix" json:"suffix,omitempty"`
	Contains *string  `protobuf:"bytes,9,opt,name=contains" json:"contains,omitempty"`
	In       []string `protobuf:"bytes,10,rep,name=in" json:"in,omitempty"`
	NotIn    []string `protobuf:"bytes,11,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// Types that are valid to be assigned to WellKnown:
	//	*StringRules_Email
	//	*StringRules_Hostname
	//	*StringRules_Ip
	//	*StringRules_Ipv4
	//	*StringRules_Ipv6
	//	*StringRules_Uri
	//	*StringRules_UriRef
	WellKnown            isStringRules_WellKnown `protobuf_oneof:"well_known"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *StringRules) Reset()         { *m = StringRules{} }
func (m *StringRules) String() string { return proto.CompactTextString(m) }
func (*StringRules) ProtoMessage()    {}
func (*StringRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{14}
}
func (m *StringRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StringRules.Unmarshal(m, b)
}
func (m *StringRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StringRules.Marshal(b, m, deterministic)
}
func (dst *StringRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StringRules.Merge(dst, src)
}
func (m *StringRules) XXX_Size() int {
	return xxx_messageInfo_StringRules.Size(m)
}
func (m *StringRules) XXX_DiscardUnknown() {
	xxx_messageInfo_StringRules.DiscardUnknown(m)
}

var xxx_messageInfo_StringRules proto.InternalMessageInfo

type isStringRules_WellKnown interface {
	isStringRules_WellKnown()
}

type StringRules_Email struct {
	Email bool `protobuf:"varint,12,opt,name=email,oneof"`
}
type StringRules_Hostname struct {
	Hostname bool `protobuf:"varint,13,opt,name=hostname,oneof"`
}
type StringRules_Ip struct {
	Ip bool `protobuf:"varint,14,opt,name=ip,oneof"`
}
type StringRules_Ipv4 struct {
	Ipv4 bool `protobuf:"varint,15,opt,name=ipv4,oneof"`
}
type StringRules_Ipv6 struct {
	Ipv6 bool `protobuf:"varint,16,opt,name=ipv6,oneof"`
}
type StringRules_Uri struct {
	Uri bool `protobuf:"varint,17,opt,name=uri,oneof"`
}
type StringRules_UriRef struct {
	UriRef bool `protobuf:"varint,18,opt,name=uri_ref,json=uriRef,oneof"`
}

func (*StringRules_Email) isStringRules_WellKnown()    {}
func (*StringRules_Hostname) isStringRules_WellKnown() {}
func (*StringRules_Ip) isStringRules_WellKnown()       {}
func (*StringRules_Ipv4) isStringRules_WellKnown()     {}
func (*StringRules_Ipv6) isStringRules_WellKnown()     {}
func (*StringRules_Uri) isStringRules_WellKnown()      {}
func (*StringRules_UriRef) isStringRules_WellKnown()   {}

func (m *StringRules) GetWellKnown() isStringRules_WellKnown {
	if m != nil {
		return m.WellKnown
	}
	return nil
}

func (m *StringRules) GetConst() string {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return ""
}

func (m *StringRules) GetLen() uint64 {
	if m != nil && m.Len != nil {
		return *m.Len
	}
	return 0
}

func (m *StringRules) GetMinLen() uint64 {
	if m != nil && m.MinLen != nil {
		return *m.MinLen
	}
	return 0
}

func (m *StringRules) GetMaxLen() uint64 {
	if m != nil && m.MaxLen != nil {
		return *m.MaxLen
	}
	return 0
}

func (m *StringRules) GetLenBytes() uint64 {
	if m != nil && m.LenBytes != nil {
		return *m.LenBytes
	}
	return 0
}

func (m *StringRules) GetMinBytes() uint64 {
	if m != nil && m.MinBytes != nil {
		return *m.MinBytes
	}
	return 0
}

func (m *StringRules) GetMaxBytes() uint64 {
	if m != nil && m.MaxBytes != nil {
		return *m.MaxBytes
	}
	return 0
}

func (m *StringRules) GetPattern() string {
	if m != nil && m.Pattern != nil {
		return *m.Pattern
	}
	return ""
}

func (m *StringRules) GetPrefix() string {
	if m != nil && m.Prefix != nil {
		return *m.Prefix
	}
	return ""
}

func (m *StringRules) GetSuffix() string {
	if m != nil && m.Suffix != nil {
		return *m.Suffix
	}
	return ""
}

func (m *StringRules) GetContains() string {
	if m != nil && m.Contains != nil {
		return *m.Contains
	}
	return ""
}

func (m *StringRules) GetIn() []string {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *StringRules) GetNotIn() []string {
	if m != nil {
		return m.NotIn
	}
	return nil
}

func (m *StringRules) GetEmail() bool {
	if x, ok := m.GetWellKnown().(*StringRules_Email); ok {
		return x.Email
	}
	return false
}

func (m *StringRules) GetHostname() bool {
	if x, ok := m.GetWellKnown().(*StringRules_Hostname); ok {
		return x.Hostname
	}
	return false
}

func (m *StringRules) GetIp() bool {
	if x, ok := m.GetWellKnown().(*StringRules_Ip); ok {
		return x.Ip
	}
	return false
}

func (m *StringRules) GetIpv4() bool {
	if x, ok := m.GetWellKnown().(*StringRules_Ipv4); ok {
		return x.Ipv4
	}
	return false
}

func (m *StringRules) GetIpv6() bool {
	if x, ok := m.GetWellKnown().(*StringRules_Ipv6); ok {
		return x.Ipv6
	}
	return false
}

func (m *StringRules) GetUri() bool {
	if x, ok := m.GetWellKnown().(*StringRules_Uri); ok {
		return x.Uri
	}
	return false
}

func (m *StringRules) GetUriRef() bool {
	if x, ok := m.GetWellKnown().(*StringRules_UriRef); ok {
		return x.UriRef
	}
	return false
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*StringRules) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _StringRules_OneofMarshaler, _StringRules_OneofUnmarshaler, _StringRules_OneofSizer, []interface{}{
		(*StringRules_Email)(nil),
		(*StringRules_Hostname)(nil),
		(*StringRules_Ip)(nil),
		(*StringRules_Ipv4)(nil),
		(*StringRules_Ipv6)(nil),
		(*StringRules_Uri)(nil),
		(*StringRules_UriRef)(nil),
	}
}

func _StringRules_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*StringRules)
	// well_known
	switch x := m.WellKnown.(type) {
	case *StringRules_Email:
		t := uint64(0)
		if x.Email {
			t = 1
		}
		b.EncodeVarint(12<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *StringRules_Hostname:
		t := uint64(0)
		if x.Hostname {
			t = 1
		}
		b.EncodeVarint(13<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *StringRules_Ip:
		t := uint64(0)
		if x.Ip {
			t = 1
		}
		b.EncodeVarint(14<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *StringRules_Ipv4:
		t := uint64(0)
		if x.Ipv4 {
			t = 1
		}
		b.EncodeVarint(15<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *StringRules_Ipv6:
		t := uint64(0)
		if x.Ipv6 {
			t = 1
		}
		b.EncodeVarint(16<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *StringRules_Uri:
		t := uint64(0)
		if x.Uri {
			t = 1
		}
		b.EncodeVarint(17<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *StringRules_UriRef:
		t := uint64(0)
		if x.UriRef {
			t = 1
		}
		b.EncodeVarint(18<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case nil:
	default:
		return fmt.Errorf("StringRules.WellKnown has unexpected type %T", x)
	}
	return nil
}

func _StringRules_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*StringRules)
	switch tag {
	case 12: // well_known.email
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.WellKnown = &StringRules_Email{x != 0}
		return true, err
	case 13: // well_known.hostname
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.WellKnown = &StringRules_Hostname{x != 0}
		return true, err
	case 14: // well_known.ip
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.WellKnown = &StringRules_Ip{x != 0}
		return true, err
	case 15: // well_known.ipv4
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.WellKnown = &StringRules_Ipv4{x != 0}
		return true, err
	case 16: // well_known.ipv6
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.WellKnown = &StringRules_Ipv6{x != 0}
		return true, err
	case 17: // well_known.uri
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.WellKnown = &StringRules_Uri{x != 0}
		return true, err
	case 18: // well_known.uri_ref
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.WellKnown = &StringRules_UriRef{x != 0}
		return true, err
	default:
		return false, nil
	}
}

func _StringRules_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*StringRules)
	// well_known
	switch x := m.WellKnown.(type) {
	case *StringRules_Email:
		n += 1 // tag and wire
		n += 1
	case *StringRules_Hostname:
		n += 1 // tag and wire
		n += 1
	case *StringRules_Ip:
		n += 1 // tag and wire
		n += 1
	case *StringRules_Ipv4:
		n += 1 // tag and wire
		n += 1
	case *StringRules_Ipv6:
		n += 2 // tag and wire
		n += 1
	case *StringRules_Uri:
		n += 2 // tag and wire
		n += 1
	case *StringRules_UriRef:
		n += 2 // tag and wire
		n += 1
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type BytesRules struct {
	Const    []byte   `protobuf:"bytes,1,opt,name=const" json:"const,omitempty"`
	Len      *uint64  `protobuf:"varint,13,opt,name=len" json:"len,omitempty"`
	MinLen   *uint64  `protobuf:"varint,2,opt,name=min_len,json=minLen" json:"min_len,omitempty"`
	MaxLen   *uint64  `protobuf:"varint,3,opt,name=max_len,json=maxLen" json:"max_len,omitempty"`
	Pattern  *string  `protobuf:"bytes,4,opt,name=pattern" json:"pattern,omitempty"`
	Prefix   []byte   `protobuf:"bytes,5,opt,name=prefix" json:"prefix,omitempty"`
	Suffix   []byte   `protobuf:"bytes,6,opt,name=suffix" json:"suffix,omitempty"`
	Contains []byte   `protobuf:"bytes,7,opt,name=contains" json:"contains,omitempty"`
	In       [][]byte `protobuf:"bytes,8,rep,name=in" json:"in,omitempty"`
	NotIn    [][]byte `protobuf:"bytes,9,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	// Types that are valid to be assigned to WellKnown:
	//	*BytesRules_Ip
	//	*BytesRules_Ipv4
	//	*BytesRules_Ipv6
	WellKnown            isBytesRules_WellKnown `protobuf_oneof:"well_known"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *BytesRules) Reset()         { *m = BytesRules{} }
func (m *BytesRules) String() string { return proto.CompactTextString(m) }
func (*BytesRules) ProtoMessage()    {}
func (*BytesRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{15}
}
func (m *BytesRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BytesRules.Unmarshal(m, b)
}
func (m *BytesRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BytesRules.Marshal(b, m, deterministic)
}
func (dst *BytesRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BytesRules.Merge(dst, src)
}
func (m *BytesRules) XXX_Size() int {
	return xxx_messageInfo_BytesRules.Size(m)
}
func (m *BytesRules) XXX_DiscardUnknown() {
	xxx_messageInfo_BytesRules.DiscardUnknown(m)
}

var xxx_messageInfo_BytesRules proto.InternalMessageInfo

type isBytesRules_WellKnown interface {
	isBytesRules_WellKnown()
}

type BytesRules_Ip struct {
	Ip bool `protobuf:"varint,10,opt,name=ip,oneof"`
}
type BytesRules_Ipv4 struct {
	Ipv4 bool `protobuf:"varint,11,opt,name=ipv4,oneof"`
}
type BytesRules_Ipv6 struct {
	Ipv6 bool `protobuf:"varint,12,opt,name=ipv6,oneof"`
}

func (*BytesRules_Ip) isBytesRules_WellKnown()   {}
func (*BytesRules_Ipv4) isBytesRules_WellKnown() {}
func (*BytesRules_Ipv6) isBytesRules_WellKnown() {}

func (m *BytesRules) GetWellKnown() isBytesRules_WellKnown {
	if m != nil {
		return m.WellKnown
	}
	return nil
}

func (m *BytesRules) GetConst() []byte {
	if m != nil {
		return m.Const
	}
	return nil
}

func (m *BytesRules) GetLen() uint64 {
	if m != nil && m.Len != nil {
		return *m.Len
	}
	return 0
}

func (m *BytesRules) GetMinLen() uint64 {
	if m != nil && m.MinLen != nil {
		return *m.MinLen
	}
	return 0
}

func (m *BytesRules) GetMaxLen() uint64 {
	if m != nil && m.MaxLen != nil {
		return *m.MaxLen
	}
	return 0
}

func (m *BytesRules) GetPattern() string {
	if m != nil && m.Pattern != nil {
		return *m.Pattern
	}
	return ""
}

func (m *BytesRules) GetPrefix() []byte {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *BytesRules) GetSuffix() []byte {
	if m != nil {
		return m.Suffix
	}
	return nil
}

func (m *BytesRules) GetContains() []byte {
	if m != nil {
		return m.Contains
	}
	return nil
}

func (m *BytesRules) GetIn() [][]byte {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *BytesRules) GetNotIn() [][]byte {
	if m != nil {
		return m.NotIn
	}
	return nil
}

func (m *BytesRules) GetIp() bool {
	if x, ok := m.GetWellKnown().(*BytesRules_Ip); ok {
		return x.Ip
	}
	return false
}

func (m *BytesRules) GetIpv4() bool {
	if x, ok := m.GetWellKnown().(*BytesRules_Ipv4); ok {
		return x.Ipv4
	}
	return false
}

func (m *BytesRules) GetIpv6() bool {
	if x, ok := m.GetWellKnown().(*BytesRules_Ipv6); ok {
		return x.Ipv6
	}
	return false
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*BytesRules) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _BytesRules_OneofMarshaler, _BytesRules_OneofUnmarshaler, _BytesRules_OneofSizer, []interface{}{
		(*BytesRules_Ip)(nil),
		(*BytesRules_Ipv4)(nil),
		(*BytesRules_Ipv6)(nil),
	}
}

func _BytesRules_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*BytesRules)
	// well_known
	switch x := m.WellKnown.(type) {
	case *BytesRules_Ip:
		t := uint64(0)
		if x.Ip {
			t = 1
		}
		b.EncodeVarint(10<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *BytesRules_Ipv4:
		t := uint64(0)
		if x.Ipv4 {
			t = 1
		}
		b.EncodeVarint(11<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *BytesRules_Ipv6:
		t := uint64(0)
		if x.Ipv6 {
			t = 1
		}
		b.EncodeVarint(12<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case nil:
	default:
		return fmt.Errorf("BytesRules.WellKnown has unexpected type %T", x)
	}
	return nil
}

func _BytesRules_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*BytesRules)
	switch tag {
	case 10: // well_known.ip
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.WellKnown = &BytesRules_Ip{x != 0}
		return true, err
	case 11: // well_known.ipv4
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.WellKnown = &BytesRules_Ipv4{x != 0}
		return true, err
	case 12: // well_known.ipv6
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.WellKnown = &BytesRules_Ipv6{x != 0}
		return true, err
	default:
		return false, nil
	}
}

func _BytesRules_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*BytesRules)
	// well_known
	switch x := m.WellKnown.(type) {
	case *BytesRules_Ip:
		n += 1 // tag and wire
		n += 1
	case *BytesRules_Ipv4:
		n += 1 // tag and wire
		n += 1
	case *BytesRules_Ipv6:
		n += 1 // tag and wire
		n += 1
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type EnumRules struct {
	Const                *int32   `protobuf:"varint,1,opt,name=const" json:"const,omitempty"`
	DefinedOnly          *bool    `protobuf:"varint,2,opt,name=defined_only,json=definedOnly" json:"defined_only,omitempty"`
	In                   []int32  `protobuf:"varint,3,rep,name=in" json:"in,omitempty"`
	NotIn                []int32  `protobuf:"varint,4,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EnumRules) Reset()         { *m = EnumRules{} }
func (m *EnumRules) String() string { return proto.CompactTextString(m) }
func (*EnumRules) ProtoMessage()    {}
func (*EnumRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{16}
}
func (m *EnumRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EnumRules.Unmarshal(m, b)
}
func (m *EnumRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EnumRules.Marshal(b, m, deterministic)
}
func (dst *EnumRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnumRules.Merge(dst, src)
}
func (m *EnumRules) XXX_Size() int {
	return xxx_messageInfo_EnumRules.Size(m)
}
func (m *EnumRules) XXX_DiscardUnknown() {
	xxx_messageInfo_EnumRules.DiscardUnknown(m)
}

var xxx_messageInfo_EnumRules proto.InternalMessageInfo

func (m *EnumRules) GetConst() int32 {
	if m != nil && m.Const != nil {
		return *m.Const
	}
	return 0
}

func (m *EnumRules) GetDefinedOnly() bool {
	if m != nil && m.DefinedOnly != nil {
		return *m.DefinedOnly
	}
	return false
}

func (m *EnumRules) GetIn() []int32 {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *EnumRules) GetNotIn() []int32 {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type MessageRules struct {
	Skip                 *bool    `protobuf:"varint,1,opt,name=skip" json:"skip,omitempty"`
	Required             *bool    `protobuf:"varint,2,opt,name=required" json:"required,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MessageRules) Reset()         { *m = MessageRules{} }
func (m *MessageRules) String() string { return proto.CompactTextString(m) }
func (*MessageRules) ProtoMessage()    {}
func (*MessageRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{17}
}
func (m *MessageRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageRules.Unmarshal(m, b)
}
func (m *MessageRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageRules.Marshal(b, m, deterministic)
}
func (dst *MessageRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageRules.Merge(dst, src)
}
func (m *MessageRules) XXX_Size() int {
	return xxx_messageInfo_MessageRules.Size(m)
}
func (m *MessageRules) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageRules.DiscardUnknown(m)
}

var xxx_messageInfo_MessageRules proto.InternalMessageInfo

func (m *MessageRules) GetSkip() bool {
	if m != nil && m.Skip != nil {
		return *m.Skip
	}
	return false
}

func (m *MessageRules) GetRequired() bool {
	if m != nil && m.Required != nil {
		return *m.Required
	}
	return false
}

type RepeatedRules struct {
	MinItems             *uint64     `protobuf:"varint,1,opt,name=min_items,json=minItems" json:"min_items,omitempty"`
	MaxItems             *uint64     `protobuf:"varint,2,opt,name=max_items,json=maxItems" json:"max_items,omitempty"`
	Unique               *bool       `protobuf:"varint,3,opt,name=unique" json:"unique,omitempty"`
	Items                *FieldRules `protobuf:"bytes,4,opt,name=items" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *RepeatedRules) Reset()         { *m = RepeatedRules{} }
func (m *RepeatedRules) String() string { return proto.CompactTextString(m) }
func (*RepeatedRules) ProtoMessage()    {}
func (*RepeatedRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{18}
}
func (m *RepeatedRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RepeatedRules.Unmarshal(m, b)
}
func (m *RepeatedRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RepeatedRules.Marshal(b, m, deterministic)
}
func (dst *RepeatedRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepeatedRules.Merge(dst, src)
}
func (m *RepeatedRules) XXX_Size() int {
	return xxx_messageInfo_RepeatedRules.Size(m)
}
func (m *RepeatedRules) XXX_DiscardUnknown() {
	xxx_messageInfo_RepeatedRules.DiscardUnknown(m)
}

var xxx_messageInfo_RepeatedRules proto.InternalMessageInfo

func (m *RepeatedRules) GetMinItems() uint64 {
	if m != nil && m.MinItems != nil {
		return *m.MinItems
	}
	return 0
}

func (m *RepeatedRules) GetMaxItems() uint64 {
	if m != nil && m.MaxItems != nil {
		return *m.MaxItems
	}
	return 0
}

func (m *RepeatedRules) GetUnique() bool {
	if m != nil && m.Unique != nil {
		return *m.Unique
	}
	return false
}

func (m *RepeatedRules) GetItems() *FieldRules {
	if m != nil {
		return m.Items
	}
	return nil
}

type MapRules struct {
	MinPairs             *uint64     `protobuf:"varint,1,opt,name=min_pairs,json=minPairs" json:"min_pairs,omitempty"`
	MaxPairs             *uint64     `protobuf:"varint,2,opt,name=max_pairs,json=maxPairs" json:"max_pairs,omitempty"`
	NoSparse             *bool       `protobuf:"varint,3,opt,name=no_sparse,json=noSparse" json:"no_sparse,omitempty"`
	Keys                 *FieldRules `protobuf:"bytes,4,opt,name=keys" json:"keys,omitempty"`
	Values               *FieldRules `protobuf:"bytes,5,opt,name=values" json:"values,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *MapRules) Reset()         { *m = MapRules{} }
func (m *MapRules) String() string { return proto.CompactTextString(m) }
func (*MapRules) ProtoMessage()    {}
func (*MapRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{19}
}
func (m *MapRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MapRules.Unmarshal(m, b)
}
func (m *MapRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MapRules.Marshal(b, m, deterministic)
}
func (dst *MapRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MapRules.Merge(dst, src)
}
func (m *MapRules) XXX_Size() int {
	return xxx_messageInfo_MapRules.Size(m)
}
func (m *MapRules) XXX_DiscardUnknown() {
	xxx_messageInfo_MapRules.DiscardUnknown(m)
}

var xxx_messageInfo_MapRules proto.InternalMessageInfo

func (m *MapRules) GetMinPairs() uint64 {
	if m != nil && m.MinPairs != nil {
		return *m.MinPairs
	}
	return 0
}

func (m *MapRules) GetMaxPairs() uint64 {
	if m != nil && m.MaxPairs != nil {
		return *m.MaxPairs
	}
	return 0
}

func (m *MapRules) GetNoSparse() bool {
	if m != nil && m.NoSparse != nil {
		return *m.NoSparse
	}
	return false
}

func (m *MapRules) GetKeys() *FieldRules {
	if m != nil {
		return m.Keys
	}
	return nil
}

func (m *MapRules) GetValues() *FieldRules {
	if m != nil {
		return m.Values
	}
	return nil
}

type AnyRules struct {
	Required             *bool    `protobuf:"varint,1,opt,name=required" json:"required,omitempty"`
	In                   []string `protobuf:"bytes,2,rep,name=in" json:"in,omitempty"`
	NotIn                []string `protobuf:"bytes,3,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AnyRules) Reset()         { *m = AnyRules{} }
func (m *AnyRules) String() string { return proto.CompactTextString(m) }
func (*AnyRules) ProtoMessage()    {}
func (*AnyRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{20}
}
func (m *AnyRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AnyRules.Unmarshal(m, b)
}
func (m *AnyRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AnyRules.Marshal(b, m, deterministic)
}
func (dst *AnyRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnyRules.Merge(dst, src)
}
func (m *AnyRules) XXX_Size() int {
	return xxx_messageInfo_AnyRules.Size(m)
}
func (m *AnyRules) XXX_DiscardUnknown() {
	xxx_messageInfo_AnyRules.DiscardUnknown(m)
}

var xxx_messageInfo_AnyRules proto.InternalMessageInfo

func (m *AnyRules) GetRequired() bool {
	if m != nil && m.Required != nil {
		return *m.Required
	}
	return false
}

func (m *AnyRules) GetIn() []string {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *AnyRules) GetNotIn() []string {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type DurationRules struct {
	Required             *bool                `protobuf:"varint,1,opt,name=required" json:"required,omitempty"`
	Const                *duration.Duration   `protobuf:"bytes,2,opt,name=const" json:"const,omitempty"`
	Lt                   *duration.Duration   `protobuf:"bytes,3,opt,name=lt" json:"lt,omitempty"`
	Lte                  *duration.Duration   `protobuf:"bytes,4,opt,name=lte" json:"lte,omitempty"`
	Gt                   *duration.Duration   `protobuf:"bytes,5,opt,name=gt" json:"gt,omitempty"`
	Gte                  *duration.Duration   `protobuf:"bytes,6,opt,name=gte" json:"gte,omitempty"`
	In                   []*duration.Duration `protobuf:"bytes,7,rep,name=in" json:"in,omitempty"`
	NotIn                []*duration.Duration `protobuf:"bytes,8,rep,name=not_in,json=notIn" json:"not_in,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *DurationRules) Reset()         { *m = DurationRules{} }
func (m *DurationRules) String() string { return proto.CompactTextString(m) }
func (*DurationRules) ProtoMessage()    {}
func (*DurationRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{21}
}
func (m *DurationRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DurationRules.Unmarshal(m, b)
}
func (m *DurationRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DurationRules.Marshal(b, m, deterministic)
}
func (dst *DurationRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DurationRules.Merge(dst, src)
}
func (m *DurationRules) XXX_Size() int {
	return xxx_messageInfo_DurationRules.Size(m)
}
func (m *DurationRules) XXX_DiscardUnknown() {
	xxx_messageInfo_DurationRules.DiscardUnknown(m)
}

var xxx_messageInfo_DurationRules proto.InternalMessageInfo

func (m *DurationRules) GetRequired() bool {
	if m != nil && m.Required != nil {
		return *m.Required
	}
	return false
}

func (m *DurationRules) GetConst() *duration.Duration {
	if m != nil {
		return m.Const
	}
	return nil
}

func (m *DurationRules) GetLt() *duration.Duration {
	if m != nil {
		return m.Lt
	}
	return nil
}

func (m *DurationRules) GetLte() *duration.Duration {
	if m != nil {
		return m.Lte
	}
	return nil
}

func (m *DurationRules) GetGt() *duration.Duration {
	if m != nil {
		return m.Gt
	}
	return nil
}

func (m *DurationRules) GetGte() *duration.Duration {
	if m != nil {
		return m.Gte
	}
	return nil
}

func (m *DurationRules) GetIn() []*duration.Duration {
	if m != nil {
		return m.In
	}
	return nil
}

func (m *DurationRules) GetNotIn() []*duration.Duration {
	if m != nil {
		return m.NotIn
	}
	return nil
}

type TimestampRules struct {
	Required             *bool                `protobuf:"varint,1,opt,name=required" json:"required,omitempty"`
	Const                *timestamp.Timestamp `protobuf:"bytes,2,opt,name=const" json:"const,omitempty"`
	Lt                   *timestamp.Timestamp `protobuf:"bytes,3,opt,name=lt" json:"lt,omitempty"`
	Lte                  *timestamp.Timestamp `protobuf:"bytes,4,opt,name=lte" json:"lte,omitempty"`
	Gt                   *timestamp.Timestamp `protobuf:"bytes,5,opt,name=gt" json:"gt,omitempty"`
	Gte                  *timestamp.Timestamp `protobuf:"bytes,6,opt,name=gte" json:"gte,omitempty"`
	LtNow                *bool                `protobuf:"varint,7,opt,name=lt_now,json=ltNow" json:"lt_now,omitempty"`
	GtNow                *bool                `protobuf:"varint,8,opt,name=gt_now,json=gtNow" json:"gt_now,omitempty"`
	Within               *duration.Duration   `protobuf:"bytes,9,opt,name=within" json:"within,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *TimestampRules) Reset()         { *m = TimestampRules{} }
func (m *TimestampRules) String() string { return proto.CompactTextString(m) }
func (*TimestampRules) ProtoMessage()    {}
func (*TimestampRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_validate_42a9c75c83428773, []int{22}
}
func (m *TimestampRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TimestampRules.Unmarshal(m, b)
}
func (m *TimestampRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TimestampRules.Marshal(b, m, deterministic)
}
func (dst *TimestampRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TimestampRules.Merge(dst, src)
}
func (m *TimestampRules) XXX_Size() int {
	return xxx_messageInfo_TimestampRules.Size(m)
}
func (m *TimestampRules) XXX_DiscardUnknown() {
	xxx_messageInfo_TimestampRules.DiscardUnknown(m)
}

var xxx_messageInfo_TimestampRules proto.InternalMessageInfo

func (m *TimestampRules) GetRequired() bool {
	if m != nil && m.Required != nil {
		return *m.Required
	}
	return false
}

func (m *TimestampRules) GetConst() *timestamp.Timestamp {
	if m != nil {
		return m.Const
	}
	return nil
}

func (m *TimestampRules) GetLt() *timestamp.Timestamp {
	if m != nil {
		return m.Lt
	}
	return nil
}

func (m *TimestampRules) GetLte() *timestamp.Timestamp {
	if m != nil {
		return m.Lte
	}
	return nil
}

func (m *TimestampRules) GetGt() *timestamp.Timestamp {
	if m != nil {
		return m.Gt
	}
	return nil
}

func (m *TimestampRules) GetGte() *timestamp.Timestamp {
	if m != nil {
		return m.Gte
	}
	return nil
}

func (m *TimestampRules) GetLtNow() bool {
	if m != nil && m.LtNow != nil {
		return *m.LtNow
	}
	return false
}

func (m *TimestampRules) GetGtNow() bool {
	if m != nil && m.GtNow != nil {
		return *m.GtNow
	}
	return false
}

func (m *TimestampRules) GetWithin() *duration.Duration {
	if m != nil {
		return m.Within
	}
	return nil
}

var E_Disabled = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.MessageOptions)(nil),
	ExtensionType: (*bool)(nil),
	Field:         919191,
	Name:          "validate.disabled",
	Tag:           "varint,919191,opt,name=disabled",
	Filename:      "validate/validate.proto",
}

var E_Required = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.OneofOptions)(nil),
	ExtensionType: (*bool)(nil),
	Field:         919191,
	Name:          "validate.required",
	Tag:           "varint,919191,opt,name=required",
	Filename:      "validate/validate.proto",
}

var E_Rules = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.FieldOptions)(nil),
	ExtensionType: (*FieldRules)(nil),
	Field:         919191,
	Name:          "validate.rules",
	Tag:           "bytes,919191,opt,name=rules",
	Filename:      "validate/validate.proto",
}

func init() {
	proto.RegisterType((*FieldRules)(nil), "validate.FieldRules")
	proto.RegisterType((*FloatRules)(nil), "validate.FloatRules")
	proto.RegisterType((*DoubleRules)(nil), "validate.DoubleRules")
	proto.RegisterType((*Int32Rules)(nil), "validate.Int32Rules")
	proto.RegisterType((*Int64Rules)(nil), "validate.Int64Rules")
	proto.RegisterType((*UInt32Rules)(nil), "validate.UInt32Rules")
	proto.RegisterType((*UInt64Rules)(nil), "validate.UInt64Rules")
	proto.RegisterType((*SInt32Rules)(nil), "validate.SInt32Rules")
	proto.RegisterType((*SInt64Rules)(nil), "validate.SInt64Rules")
	proto.RegisterType((*Fixed32Rules)(nil), "validate.Fixed32Rules")
	proto.RegisterType((*Fixed64Rules)(nil), "validate.Fixed64Rules")
	proto.RegisterType((*SFixed32Rules)(nil), "validate.SFixed32Rules")
	proto.RegisterType((*SFixed64Rules)(nil), "validate.SFixed64Rules")
	proto.RegisterType((*BoolRules)(nil), "validate.BoolRules")
	proto.RegisterType((*StringRules)(nil), "validate.StringRules")
	proto.RegisterType((*BytesRules)(nil), "validate.BytesRules")
	proto.RegisterType((*EnumRules)(nil), "validate.EnumRules")
	proto.RegisterType((*MessageRules)(nil), "validate.MessageRules")
	proto.RegisterType((*RepeatedRules)(nil), "validate.RepeatedRules")
	proto.RegisterType((*MapRules)(nil), "validate.MapRules")
	proto.RegisterType((*AnyRules)(nil), "validate.AnyRules")
	proto.RegisterType((*DurationRules)(nil), "validate.DurationRules")
	proto.RegisterType((*TimestampRules)(nil), "validate.TimestampRules")
	proto.RegisterExtension(E_Disabled)
	proto.RegisterExtension(E_Required)
	proto.RegisterExtension(E_Rules)
}

func init() { proto.RegisterFile("validate/validate.proto", fileDescriptor_validate_42a9c75c83428773) }

var fileDescriptor_validate_42a9c75c83428773 = []byte{
	// 1609 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x98, 0xcb, 0x6e, 0xdb, 0x46,
	0x17, 0xc7, 0x3f, 0xf1, 0x26, 0x6a, 0x2c, 0x45, 0xd2, 0xc4, 0x76, 0x18, 0x7f, 0x97, 0x38, 0x5a,
	0x7c, 0x70, 0x52, 0xc7, 0x4e, 0x1d, 0x57, 0x08, 0x52, 0xb4, 0x40, 0x8d, 0x34, 0x68, 0xd0, 0xa6,
	0x29, 0xe8, 0x66, 0xd3, 0x8d, 0x40, 0x5b, 0x23, 0x65, 0x60, 0x6a, 0xc8, 0x90, 0x54, 0x6c, 0x3d,
	0x44, 0xda, 0xee, 0xfa, 0x2c, 0x5d, 0x75, 0xdf, 0x37, 0xe9, 0xba, 0xdb, 0x2e, 0x8a, 0xb9, 0xf1,
	0x72, 0x48, 0xcb, 0x8b, 0xee, 0x34, 0xe7, 0xfc, 0xcf, 0xcc, 0x0f, 0xff, 0x11, 0x67, 0x0e, 0x89,
	0xee, 0xbc, 0x0f, 0x42, 0x3a, 0x0d, 0x32, 0x72, 0xa8, 0x7f, 0x1c, 0xc4, 0x49, 0x94, 0x45, 0xd8,
	0xd5, 0xe3, 0x9d, 0xdd, 0x79, 0x14, 0xcd, 0x43, 0x72, 0x28, 0xe2, 0x67, 0xcb, 0xd9, 0xe1, 0x94,
	0xa4, 0xe7, 0x09, 0x8d, 0xb3, 0x28, 0x91, 0xda, 0x9d, 0xff, 0xd5, 0x14, 0xcb, 0x24, 0xc8, 0x68,
	0xc4, 0x54, 0xfe, 0x1e, 0xcc, 0x67, 0x74, 0x41, 0xd2, 0x2c, 0x58, 0xc4, 0x52, 0x30, 0xfa, 0xdd,
	0x45, 0xe8, 0x05, 0x25, 0xe1, 0xd4, 0x5f, 0x86, 0x24, 0xc5, 0xfb, 0xc8, 0x9e, 0x85, 0x51, 0x90,
	0x79, 0xad, 0xdd, 0xd6, 0xde, 0xc6, 0xd1, 0xe6, 0x41, 0xce, 0xf6, 0x82, 0x87, 0x85, 0xe8, 0xab,
	0x7f, 0xf9, 0x52, 0x84, 0x0f, 0x91, 0x33, 0x8d, 0x96, 0x67, 0x21, 0xf1, 0x0c, 0x21, 0xdf, 0x2a,
	0xe4, 0xcf, 0x45, 0x5c, 0xeb, 0x95, 0x8c, 0x4f, 0x4f, 0x59, 0xf6, 0xe4, 0xc8, 0x33, 0xe1, 0xf4,
	0x2f, 0x79, 0x38, 0x9f, 0x5e, 0x88, 0x94, 0x7a, 0x7c, 0xec, 0x59, 0x0d, 0xea, 0xf1, 0x71, 0x59,
	0x3d, 0x3e, 0xe6, 0x30, 0x4b, 0x39, 0xb9, 0x0d, 0x61, 0xde, 0x54, 0x66, 0x57, 0x32, 0x5d, 0x30,
	0x3e, 0xf6, 0x9c, 0xa6, 0x82, 0x62, 0x01, 0x25, 0xe3, 0x05, 0xa9, 0x5c, 0xa1, 0x0d, 0x0b, 0x4e,
	0xab, 0x2b, 0xa4, 0xf9, 0x0a, 0xa9, 0x5c, 0xc1, 0x6d, 0x2a, 0x28, 0xad, 0x20, 0x65, 0xf8, 0x08,
	0xb5, 0x67, 0xf4, 0x8a, 0x4c, 0x9f, 0x1c, 0x79, 0x1d, 0x51, 0xb1, 0x5d, 0xda, 0x00, 0x99, 0xd0,
	0x25, 0x5a, 0x98, 0xd7, 0x8c, 0x8f, 0x3d, 0xd4, 0x58, 0x53, 0x2c, 0xa3, 0x85, 0xf8, 0x13, 0xe4,
	0xa6, 0x7a, 0xa1, 0x0d, 0x51, 0x74, 0xa7, 0x84, 0x06, 0x56, 0xca, 0xa5, 0x45, 0xd9, 0xf8, 0xd8,
	0xeb, 0x36, 0x97, 0x15, 0x8b, 0xe5, 0x52, 0xfc, 0x00, 0x59, 0x67, 0x51, 0x14, 0x7a, 0x3d, 0x51,
	0x72, 0xbb, 0x28, 0x39, 0x89, 0xa2, 0x50, 0xcb, 0x85, 0x44, 0x38, 0x96, 0x25, 0x94, 0xcd, 0xbd,
	0x5b, 0x35, 0xc7, 0x44, 0xbc, 0x70, 0x4c, 0x0c, 0xf9, 0x7f, 0xe4, 0x6c, 0x95, 0x91, 0xd4, 0xeb,
	0xc3, 0xff, 0xc8, 0x09, 0x0f, 0xe7, 0xff, 0x11, 0x21, 0xe2, 0x24, 0x84, 0x2d, 0x17, 0xde, 0x00,
	0x92, 0x7c, 0xc9, 0x96, 0x8b, 0x9c, 0x84, 0x4b, 0xb8, 0xad, 0x0b, 0x92, 0xa6, 0xc1, 0x9c, 0x78,
	0x43, 0x68, 0xeb, 0x2b, 0x99, 0xc8, 0x6d, 0x55, 0x42, 0xee, 0x4f, 0x42, 0x62, 0x12, 0x64, 0x64,
	0xea, 0x61, 0xe8, 0x8f, 0xaf, 0x32, 0xb9, 0x3f, 0x5a, 0x8a, 0xff, 0x8f, 0xcc, 0x45, 0x10, 0x7b,
	0xb7, 0x45, 0x05, 0x2e, 0x2d, 0x13, 0xc4, 0x5a, 0xcc, 0x05, 0x5c, 0x17, 0xb0, 0x95, 0xb7, 0x09,
	0x75, 0x5f, 0xb0, 0x55, 0xae, 0x0b, 0xd8, 0x8a, 0x63, 0xe8, 0x63, 0xc0, 0xdb, 0x82, 0x18, 0xcf,
	0x55, 0x26, 0xc7, 0xd0, 0x52, 0xfc, 0x14, 0x75, 0xf2, 0xd3, 0xc1, 0xdb, 0x16, 0x75, 0x5e, 0x51,
	0xf7, 0xbd, 0x4e, 0xe9, 0xc2, 0x42, 0x7c, 0xe2, 0x20, 0x2b, 0x5b, 0xc5, 0x64, 0xf4, 0xa1, 0x85,
	0x50, 0x71, 0x4e, 0xe0, 0x4d, 0x64, 0x9f, 0x47, 0x2c, 0x95, 0x87, 0x89, 0xe1, 0xcb, 0x01, 0xbe,
	0x85, 0x8c, 0x30, 0x13, 0x07, 0x86, 0xe1, 0x1b, 0x61, 0x86, 0x07, 0xc8, 0x0c, 0x33, 0x22, 0x4e,
	0x04, 0xc3, 0xe7, 0x3f, 0xb9, 0x62, 0x9e, 0x89, 0x87, 0xde, 0xf0, 0x8d, 0xb9, 0x50, 0xcc, 0x33,
	0x22, 0x1e, 0x6b, 0xc3, 0xe7, 0x3f, 0xb9, 0x82, 0x32, 0xcf, 0xd9, 0x35, 0xb9, 0x82, 0x32, 0xbc,
	0x85, 0x1c, 0x16, 0x65, 0x13, 0xca, 0xbc, 0xb6, 0x88, 0xd9, 0x2c, 0xca, 0x5e, 0xb2, 0xd1, 0x8f,
	0x2d, 0xb4, 0x51, 0x3a, 0x88, 0xaa, 0x40, 0xad, 0x3a, 0x50, 0x0b, 0x02, 0xb5, 0x20, 0x50, 0x0b,
	0x02, 0xb5, 0x20, 0x50, 0xab, 0x01, 0xa8, 0xa5, 0x81, 0xb8, 0x41, 0xc5, 0x49, 0x51, 0xe5, 0xb1,
	0xeb, 0x3c, 0x36, 0xe4, 0xb1, 0x21, 0x8f, 0x0d, 0x79, 0x6c, 0xc8, 0x63, 0x37, 0xf0, 0xd8, 0x80,
	0x47, 0x3d, 0xb4, 0x55, 0x1e, 0xb3, 0xce, 0x63, 0x42, 0x1e, 0x13, 0xf2, 0x98, 0x90, 0xc7, 0x84,
	0x3c, 0x66, 0x03, 0x8f, 0x59, 0xde, 0xb0, 0x37, 0xd7, 0x19, 0xd4, 0xab, 0x03, 0xf5, 0x20, 0x50,
	0x0f, 0x02, 0xf5, 0x20, 0x50, 0x0f, 0x02, 0xf5, 0x1a, 0x80, 0x7a, 0x10, 0xa8, 0xd1, 0x21, 0xab,
	0x0e, 0x64, 0x41, 0x20, 0x0b, 0x02, 0x59, 0x10, 0xc8, 0x82, 0x40, 0x56, 0x03, 0x90, 0x55, 0x06,
	0x3a, 0xbd, 0xce, 0xa1, 0x61, 0x1d, 0x68, 0x08, 0x81, 0x86, 0x10, 0x68, 0x08, 0x81, 0x86, 0x10,
	0x68, 0xd8, 0x00, 0x34, 0x84, 0x40, 0x8d, 0x0e, 0xe1, 0x3a, 0x10, 0x86, 0x40, 0x18, 0x02, 0x61,
	0x08, 0x84, 0x21, 0x10, 0x6e, 0x00, 0xc2, 0x1a, 0xe8, 0xa7, 0x16, 0xea, 0x96, 0x6f, 0xb0, 0x2a,
	0x51, 0xbb, 0x4e, 0xd4, 0x86, 0x44, 0x6d, 0x48, 0xd4, 0x86, 0x44, 0x6d, 0x48, 0xd4, 0x6e, 0x20,
	0x6a, 0xd7, 0x88, 0x1a, 0x3d, 0x72, 0xea, 0x44, 0x0e, 0x24, 0x72, 0x20, 0x91, 0x03, 0x89, 0x1c,
	0x48, 0xe4, 0x34, 0x10, 0x39, 0x9a, 0xe8, 0xe7, 0x16, 0xea, 0x9d, 0x5e, 0x6f, 0x52, 0xbf, 0x8e,
	0xd4, 0x87, 0x48, 0x7d, 0x88, 0xd4, 0x87, 0x48, 0x7d, 0x88, 0xd4, 0x6f, 0x40, 0xea, 0xd7, 0x91,
	0x1a, 0x5d, 0x1a, 0xd4, 0x91, 0x06, 0x10, 0x69, 0x00, 0x91, 0x06, 0x10, 0x69, 0x00, 0x91, 0x06,
	0x0d, 0x48, 0x03, 0x8d, 0x74, 0x1f, 0x75, 0xf2, 0x0e, 0xa5, 0x4a, 0xe3, 0x2a, 0x9a, 0xd1, 0x5f,
	0x26, 0xda, 0x28, 0x35, 0x26, 0x55, 0x55, 0x47, 0x33, 0x73, 0x46, 0xc2, 0xc4, 0x05, 0xcf, 0xcf,
	0x03, 0xc2, 0xf0, 0x1d, 0xd4, 0x5e, 0x50, 0x36, 0xe1, 0x51, 0x79, 0x6c, 0x38, 0x0b, 0xca, 0xbe,
	0x51, 0x89, 0xe0, 0x4a, 0x24, 0x4c, 0x95, 0x08, 0xae, 0x78, 0xe2, 0xdf, 0xa8, 0x13, 0x12, 0x36,
	0x91, 0xcd, 0xce, 0xa6, 0x48, 0xb9, 0x21, 0x61, 0xa2, 0xcb, 0xe1, 0x49, 0x3e, 0x9d, 0x4c, 0xca,
	0x53, 0xc6, 0x5d, 0xd0, 0x52, 0x32, 0xb8, 0x52, 0x49, 0x5b, 0x25, 0x83, 0x2b, 0x99, 0xf4, 0x50,
	0x3b, 0x0e, 0xb2, 0x8c, 0x24, 0x4c, 0x74, 0xc1, 0x1d, 0x5f, 0x0f, 0xf1, 0x36, 0x72, 0xe2, 0x84,
	0xcc, 0xe8, 0x95, 0xe8, 0x76, 0x3b, 0xbe, 0x1a, 0xf1, 0x78, 0xba, 0x9c, 0xf1, 0xb8, 0x2b, 0xe3,
	0x72, 0x84, 0x77, 0x90, 0x7b, 0x1e, 0xb1, 0x2c, 0xa0, 0x2c, 0x15, 0xcd, 0x6b, 0xc7, 0xcf, 0xc7,
	0xca, 0x70, 0xb4, 0x6b, 0xee, 0x75, 0x80, 0xe1, 0x1b, 0x22, 0x26, 0x0d, 0xc7, 0xdb, 0xc8, 0x26,
	0x8b, 0x80, 0x86, 0xa2, 0xb9, 0x74, 0x79, 0xdb, 0x26, 0x86, 0xf8, 0x3f, 0xc8, 0x7d, 0x1b, 0xa5,
	0x19, 0x0b, 0x16, 0x44, 0x34, 0x91, 0x3c, 0x95, 0x47, 0xf0, 0x00, 0x19, 0x34, 0x16, 0xfd, 0x22,
	0x8f, 0x1b, 0x34, 0xc6, 0x9b, 0xc8, 0xa2, 0xf1, 0xfb, 0x63, 0xd1, 0x13, 0xf2, 0x98, 0x18, 0xa9,
	0xe8, 0x58, 0x34, 0x7f, 0x3a, 0x3a, 0xc6, 0x18, 0x99, 0xcb, 0x84, 0x8a, 0x1e, 0x8f, 0x07, 0xf9,
	0x00, 0xdf, 0x45, 0xed, 0x65, 0x42, 0x27, 0x09, 0x99, 0x89, 0x36, 0xce, 0x15, 0xef, 0x00, 0x09,
	0xf5, 0xc9, 0xec, 0xa4, 0x8b, 0xd0, 0x25, 0x09, 0xc3, 0xc9, 0x05, 0x8b, 0x2e, 0xd9, 0xe8, 0x37,
	0x03, 0xa1, 0xa2, 0xcf, 0xac, 0xee, 0x7e, 0x17, 0xec, 0x7e, 0xef, 0x9f, 0xec, 0x7e, 0x69, 0x9b,
	0xac, 0xeb, 0xb6, 0xc9, 0x16, 0x8b, 0xd6, 0xb7, 0xc9, 0x91, 0xf1, 0x86, 0x6d, 0x6a, 0x8b, 0x0c,
	0xdc, 0x26, 0x77, 0xd7, 0xdc, 0xeb, 0x82, 0x6d, 0xea, 0x88, 0x98, 0xda, 0x26, 0x69, 0x38, 0x6a,
	0x30, 0x7c, 0xa3, 0xd1, 0xf0, 0x6e, 0xd9, 0x70, 0xe0, 0xe0, 0x05, 0xea, 0xe4, 0xbd, 0xf7, 0x35,
	0xfd, 0xd0, 0x7d, 0xd4, 0x9d, 0x92, 0x19, 0x65, 0x64, 0x3a, 0x89, 0x58, 0xb8, 0x12, 0x96, 0xb9,
	0xfe, 0x86, 0x8a, 0xbd, 0x66, 0xe1, 0x4a, 0x81, 0x9b, 0x0d, 0xed, 0x8e, 0x55, 0x6e, 0x77, 0x3e,
	0x47, 0xdd, 0x72, 0xeb, 0x8e, 0x31, 0xb2, 0xd2, 0x0b, 0x1a, 0xab, 0x47, 0x5a, 0xfc, 0xe6, 0xfe,
	0x24, 0xe4, 0xdd, 0x92, 0x26, 0x64, 0xaa, 0x56, 0xca, 0xc7, 0xbc, 0x5d, 0xea, 0x55, 0xda, 0x78,
	0xfd, 0xe0, 0xd1, 0x8c, 0x2c, 0x52, 0xd5, 0x13, 0xf0, 0x07, 0xef, 0x25, 0x1f, 0xeb, 0x07, 0x4f,
	0x26, 0x8d, 0xfc, 0xc1, 0x93, 0xc9, 0x6d, 0xe4, 0x2c, 0x19, 0x7d, 0xb7, 0x94, 0x47, 0x97, 0xeb,
	0xab, 0x11, 0x7e, 0x88, 0x6c, 0x59, 0x50, 0x7b, 0xe9, 0x2d, 0x5e, 0xd3, 0x7d, 0x29, 0x19, 0xfd,
	0xda, 0x42, 0xae, 0x7e, 0x49, 0xd0, 0x28, 0x71, 0x40, 0x93, 0x32, 0xca, 0x77, 0x7c, 0xac, 0x51,
	0x64, 0xb2, 0x40, 0xc9, 0x93, 0x2c, 0x9a, 0xa4, 0x71, 0x90, 0xa4, 0x9a, 0xc6, 0x65, 0xd1, 0xa9,
	0x18, 0xe3, 0x3d, 0x64, 0x5d, 0x90, 0xd5, 0x7a, 0x1c, 0xa1, 0xc0, 0xfb, 0xc8, 0x79, 0x1f, 0x84,
	0x4b, 0x75, 0xc8, 0x5c, 0xa7, 0x55, 0x9a, 0xd1, 0x2b, 0xe4, 0xea, 0xf7, 0x96, 0x8a, 0xe7, 0xad,
	0xaa, 0xe7, 0x6a, 0x6b, 0x8d, 0x86, 0xa3, 0xc3, 0x2c, 0x1d, 0x1d, 0xa3, 0x3f, 0x0c, 0xd4, 0xab,
	0xbc, 0xda, 0xac, 0x9d, 0xf4, 0x50, 0xff, 0xd1, 0xe4, 0x77, 0x8b, 0xbb, 0x07, 0xf2, 0x33, 0xc9,
	0x81, 0xfe, 0x4c, 0x52, 0xbc, 0x25, 0xa9, 0xff, 0xe0, 0x03, 0x71, 0xeb, 0x98, 0x37, 0xa9, 0xf9,
	0x85, 0xf4, 0x91, 0xbc, 0x90, 0xac, 0x9b, 0xb4, 0xe2, 0xae, 0x7a, 0x20, 0xee, 0x2a, 0xfb, 0xc6,
	0x79, 0xe7, 0x62, 0x5e, 0x7e, 0x8d, 0x39, 0x37, 0xce, 0x3b, 0x97, 0xf3, 0xaa, 0xdb, 0x6c, 0xfd,
	0xbc, 0x94, 0xe1, 0xc7, 0xb9, 0xa1, 0xee, 0x4d, 0x72, 0xe5, 0xf5, 0x9f, 0x06, 0xba, 0x55, 0x7d,
	0x1d, 0x5c, 0x6b, 0xf6, 0xe3, 0xaa, 0xd9, 0x3b, 0xb5, 0xf9, 0x8b, 0xb9, 0x94, 0xdb, 0x0f, 0x4b,
	0x6e, 0xaf, 0x93, 0x73, 0xbb, 0xf7, 0xcb, 0x76, 0xaf, 0x13, 0x0b, 0xbf, 0x1f, 0x96, 0xfc, 0x5e,
	0x3b, 0xf3, 0x5c, 0xcc, 0x5c, 0x18, 0xbe, 0x76, 0x66, 0xee, 0xf8, 0x16, 0x72, 0xc2, 0x6c, 0xc2,
	0xa2, 0x4b, 0x71, 0xaa, 0xba, 0xbe, 0x1d, 0x66, 0xdf, 0x46, 0x97, 0x3c, 0x3c, 0x97, 0x61, 0x57,
	0x86, 0xe7, 0x22, 0xfc, 0x31, 0x72, 0x2e, 0x69, 0xf6, 0x56, 0x9c, 0xac, 0x37, 0xec, 0xa7, 0x12,
	0x3e, 0xfb, 0x0c, 0xb9, 0x53, 0x9a, 0x06, 0x67, 0x21, 0x99, 0xe2, 0x7b, 0x35, 0xb9, 0x3a, 0xd7,
	0x5e, 0xc7, 0xbc, 0x26, 0xf5, 0x7e, 0xf9, 0xf0, 0x54, 0xee, 0x82, 0x2e, 0x79, 0xf6, 0x69, 0xb1,
	0x43, 0xf8, 0xbf, 0xb5, 0xf2, 0xd7, 0x8c, 0x44, 0xb3, 0x5a, 0xb1, 0x2e, 0x78, 0xf6, 0x35, 0xb2,
	0x13, 0xb1, 0xcf, 0xf5, 0x4a, 0xf1, 0x68, 0x57, 0x2b, 0xaf, 0x3d, 0xb5, 0xc4, 0x1c, 0x27, 0x07,
	0x3f, 0xec, 0xcf, 0x69, 0xf6, 0x76, 0x79, 0x76, 0x70, 0x1e, 0x2d, 0x0e, 0xc3, 0xd5, 0x2c, 0x93,
	0x9f, 0x27, 0xcf, 0x1f, 0xcd, 0x09, 0x7b, 0x54, 0xfb, 0x2a, 0xfa, 0x77, 0x00, 0x00, 0x00, 0xff,
	0xff, 0xe1, 0xd8, 0xec, 0xea, 0x29, 0x15, 0x00, 0x00,
}
