particle-os/debian-forge-composer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
debian-forge-composer/vendor/github.com/envoyproxy/protoc-gen-validate/validate/validate.pb.go
Tomas Hozza 07a5745875 internal/cloud/gcp: use pkg.go.dev/cloud.google.com/go for Compute Engine 
The internal GCP package used `pkg.go.dev/google.golang.org/api` [1] to
interact with Compute Engine API. Modify the package to use the new and
idiomatic `pkg.go.dev/cloud.google.com/go` [2] library for interacting
with the Compute Engine API. The new library have been already used to
interact with the Cloudbuild and Storage APIs. The new library was not
used for Compute Engine since the beginning, because at that time, it
didn't support Compute Engine.

Update go.mod and vendored packages.

[1] https://github.com/googleapis/google-api-go-client
[2] https://github.com/googleapis/google-cloud-go

Signed-off-by: Tomas Hozza <thozza@redhat.com>
2022-02-03 15:35:28 +01:00

3575 lines
108 KiB
Go
Raw Blame History

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