types.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: combos/marshaler/types.proto

/*
Package types is a generated protocol buffer package.

It is generated from these files:
	combos/marshaler/types.proto

It has these top-level messages:
	KnownTypes
	ProtoTypes
	StdTypes
	RepProtoTypes
	RepStdTypes
	MapProtoTypes
	MapStdTypes
	OneofProtoTypes
	OneofStdTypes
*/
package types

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import google_protobuf1 "github.com/gogo/protobuf/types"
import google_protobuf2 "github.com/gogo/protobuf/types"
import google_protobuf3 "github.com/gogo/protobuf/types"

import time "time"
import github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"

import types1 "github.com/gogo/protobuf/types"

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

// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type KnownTypes struct {
	Dur   *google_protobuf1.Duration    `protobuf:"bytes,1,opt,name=dur" json:"dur,omitempty"`
	Ts    *google_protobuf2.Timestamp   `protobuf:"bytes,2,opt,name=ts" json:"ts,omitempty"`
	Dbl   *google_protobuf3.DoubleValue `protobuf:"bytes,3,opt,name=dbl" json:"dbl,omitempty"`
	Flt   *google_protobuf3.FloatValue  `protobuf:"bytes,4,opt,name=flt" json:"flt,omitempty"`
	I64   *google_protobuf3.Int64Value  `protobuf:"bytes,5,opt,name=i64" json:"i64,omitempty"`
	U64   *google_protobuf3.UInt64Value `protobuf:"bytes,6,opt,name=u64" json:"u64,omitempty"`
	I32   *google_protobuf3.Int32Value  `protobuf:"bytes,7,opt,name=i32" json:"i32,omitempty"`
	U32   *google_protobuf3.UInt32Value `protobuf:"bytes,8,opt,name=u32" json:"u32,omitempty"`
	Bool  *google_protobuf3.BoolValue   `protobuf:"bytes,9,opt,name=bool" json:"bool,omitempty"`
	Str   *google_protobuf3.StringValue `protobuf:"bytes,10,opt,name=str" json:"str,omitempty"`
	Bytes *google_protobuf3.BytesValue  `protobuf:"bytes,11,opt,name=bytes" json:"bytes,omitempty"`
}

func (m *KnownTypes) Reset()                    { *m = KnownTypes{} }
func (m *KnownTypes) String() string            { return proto.CompactTextString(m) }
func (*KnownTypes) ProtoMessage()               {}
func (*KnownTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{0} }

func (m *KnownTypes) GetDur() *google_protobuf1.Duration {
	if m != nil {
		return m.Dur
	}
	return nil
}

func (m *KnownTypes) GetTs() *google_protobuf2.Timestamp {
	if m != nil {
		return m.Ts
	}
	return nil
}

func (m *KnownTypes) GetDbl() *google_protobuf3.DoubleValue {
	if m != nil {
		return m.Dbl
	}
	return nil
}

func (m *KnownTypes) GetFlt() *google_protobuf3.FloatValue {
	if m != nil {
		return m.Flt
	}
	return nil
}

func (m *KnownTypes) GetI64() *google_protobuf3.Int64Value {
	if m != nil {
		return m.I64
	}
	return nil
}

func (m *KnownTypes) GetU64() *google_protobuf3.UInt64Value {
	if m != nil {
		return m.U64
	}
	return nil
}

func (m *KnownTypes) GetI32() *google_protobuf3.Int32Value {
	if m != nil {
		return m.I32
	}
	return nil
}

func (m *KnownTypes) GetU32() *google_protobuf3.UInt32Value {
	if m != nil {
		return m.U32
	}
	return nil
}

func (m *KnownTypes) GetBool() *google_protobuf3.BoolValue {
	if m != nil {
		return m.Bool
	}
	return nil
}

func (m *KnownTypes) GetStr() *google_protobuf3.StringValue {
	if m != nil {
		return m.Str
	}
	return nil
}

func (m *KnownTypes) GetBytes() *google_protobuf3.BytesValue {
	if m != nil {
		return m.Bytes
	}
	return nil
}

type ProtoTypes struct {
	NullableTimestamp *google_protobuf2.Timestamp `protobuf:"bytes,1,opt,name=nullableTimestamp" json:"nullableTimestamp,omitempty"`
	NullableDuration  *google_protobuf1.Duration  `protobuf:"bytes,2,opt,name=nullableDuration" json:"nullableDuration,omitempty"`
	Timestamp         google_protobuf2.Timestamp  `protobuf:"bytes,3,opt,name=timestamp" json:"timestamp"`
	Duration          google_protobuf1.Duration   `protobuf:"bytes,4,opt,name=duration" json:"duration"`
}

func (m *ProtoTypes) Reset()                    { *m = ProtoTypes{} }
func (m *ProtoTypes) String() string            { return proto.CompactTextString(m) }
func (*ProtoTypes) ProtoMessage()               {}
func (*ProtoTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{1} }

func (m *ProtoTypes) GetNullableTimestamp() *google_protobuf2.Timestamp {
	if m != nil {
		return m.NullableTimestamp
	}
	return nil
}

func (m *ProtoTypes) GetNullableDuration() *google_protobuf1.Duration {
	if m != nil {
		return m.NullableDuration
	}
	return nil
}

func (m *ProtoTypes) GetTimestamp() google_protobuf2.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return google_protobuf2.Timestamp{}
}

func (m *ProtoTypes) GetDuration() google_protobuf1.Duration {
	if m != nil {
		return m.Duration
	}
	return google_protobuf1.Duration{}
}

type StdTypes struct {
	NullableTimestamp *time.Time     `protobuf:"bytes,1,opt,name=nullableTimestamp,stdtime" json:"nullableTimestamp,omitempty"`
	NullableDuration  *time.Duration `protobuf:"bytes,2,opt,name=nullableDuration,stdduration" json:"nullableDuration,omitempty"`
	Timestamp         time.Time      `protobuf:"bytes,3,opt,name=timestamp,stdtime" json:"timestamp"`
	Duration          time.Duration  `protobuf:"bytes,4,opt,name=duration,stdduration" json:"duration"`
}

func (m *StdTypes) Reset()                    { *m = StdTypes{} }
func (m *StdTypes) String() string            { return proto.CompactTextString(m) }
func (*StdTypes) ProtoMessage()               {}
func (*StdTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{2} }

func (m *StdTypes) GetNullableTimestamp() *time.Time {
	if m != nil {
		return m.NullableTimestamp
	}
	return nil
}

func (m *StdTypes) GetNullableDuration() *time.Duration {
	if m != nil {
		return m.NullableDuration
	}
	return nil
}

func (m *StdTypes) GetTimestamp() time.Time {
	if m != nil {
		return m.Timestamp
	}
	return time.Time{}
}

func (m *StdTypes) GetDuration() time.Duration {
	if m != nil {
		return m.Duration
	}
	return 0
}

type RepProtoTypes struct {
	NullableTimestamps []*google_protobuf2.Timestamp `protobuf:"bytes,1,rep,name=nullableTimestamps" json:"nullableTimestamps,omitempty"`
	NullableDurations  []*google_protobuf1.Duration  `protobuf:"bytes,2,rep,name=nullableDurations" json:"nullableDurations,omitempty"`
	Timestamps         []google_protobuf2.Timestamp  `protobuf:"bytes,3,rep,name=timestamps" json:"timestamps"`
	Durations          []google_protobuf1.Duration   `protobuf:"bytes,4,rep,name=durations" json:"durations"`
}

func (m *RepProtoTypes) Reset()                    { *m = RepProtoTypes{} }
func (m *RepProtoTypes) String() string            { return proto.CompactTextString(m) }
func (*RepProtoTypes) ProtoMessage()               {}
func (*RepProtoTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{3} }

func (m *RepProtoTypes) GetNullableTimestamps() []*google_protobuf2.Timestamp {
	if m != nil {
		return m.NullableTimestamps
	}
	return nil
}

func (m *RepProtoTypes) GetNullableDurations() []*google_protobuf1.Duration {
	if m != nil {
		return m.NullableDurations
	}
	return nil
}

func (m *RepProtoTypes) GetTimestamps() []google_protobuf2.Timestamp {
	if m != nil {
		return m.Timestamps
	}
	return nil
}

func (m *RepProtoTypes) GetDurations() []google_protobuf1.Duration {
	if m != nil {
		return m.Durations
	}
	return nil
}

type RepStdTypes struct {
	NullableTimestamps []*time.Time     `protobuf:"bytes,1,rep,name=nullableTimestamps,stdtime" json:"nullableTimestamps,omitempty"`
	NullableDurations  []*time.Duration `protobuf:"bytes,2,rep,name=nullableDurations,stdduration" json:"nullableDurations,omitempty"`
	Timestamps         []time.Time      `protobuf:"bytes,3,rep,name=timestamps,stdtime" json:"timestamps"`
	Durations          []time.Duration  `protobuf:"bytes,4,rep,name=durations,stdduration" json:"durations"`
}

func (m *RepStdTypes) Reset()                    { *m = RepStdTypes{} }
func (m *RepStdTypes) String() string            { return proto.CompactTextString(m) }
func (*RepStdTypes) ProtoMessage()               {}
func (*RepStdTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{4} }

func (m *RepStdTypes) GetNullableTimestamps() []*time.Time {
	if m != nil {
		return m.NullableTimestamps
	}
	return nil
}

func (m *RepStdTypes) GetNullableDurations() []*time.Duration {
	if m != nil {
		return m.NullableDurations
	}
	return nil
}

func (m *RepStdTypes) GetTimestamps() []time.Time {
	if m != nil {
		return m.Timestamps
	}
	return nil
}

func (m *RepStdTypes) GetDurations() []time.Duration {
	if m != nil {
		return m.Durations
	}
	return nil
}

type MapProtoTypes struct {
	NullableTimestamp map[int32]*google_protobuf2.Timestamp `protobuf:"bytes,1,rep,name=nullableTimestamp" json:"nullableTimestamp,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	Timestamp         map[int32]google_protobuf2.Timestamp  `protobuf:"bytes,2,rep,name=timestamp" json:"timestamp" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	NullableDuration  map[int32]*google_protobuf1.Duration  `protobuf:"bytes,3,rep,name=nullableDuration" json:"nullableDuration,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	Duration          map[int32]google_protobuf1.Duration   `protobuf:"bytes,4,rep,name=duration" json:"duration" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *MapProtoTypes) Reset()                    { *m = MapProtoTypes{} }
func (m *MapProtoTypes) String() string            { return proto.CompactTextString(m) }
func (*MapProtoTypes) ProtoMessage()               {}
func (*MapProtoTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{5} }

func (m *MapProtoTypes) GetNullableTimestamp() map[int32]*google_protobuf2.Timestamp {
	if m != nil {
		return m.NullableTimestamp
	}
	return nil
}

func (m *MapProtoTypes) GetTimestamp() map[int32]google_protobuf2.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *MapProtoTypes) GetNullableDuration() map[int32]*google_protobuf1.Duration {
	if m != nil {
		return m.NullableDuration
	}
	return nil
}

func (m *MapProtoTypes) GetDuration() map[int32]google_protobuf1.Duration {
	if m != nil {
		return m.Duration
	}
	return nil
}

type MapStdTypes struct {
	NullableTimestamp map[int32]*time.Time     `protobuf:"bytes,1,rep,name=nullableTimestamp,stdtime" json:"nullableTimestamp,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	Timestamp         map[int32]time.Time      `protobuf:"bytes,2,rep,name=timestamp,stdtime" json:"timestamp" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	NullableDuration  map[int32]*time.Duration `protobuf:"bytes,3,rep,name=nullableDuration,stdduration" json:"nullableDuration,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	Duration          map[int32]time.Duration  `protobuf:"bytes,4,rep,name=duration,stdduration" json:"duration" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *MapStdTypes) Reset()                    { *m = MapStdTypes{} }
func (m *MapStdTypes) String() string            { return proto.CompactTextString(m) }
func (*MapStdTypes) ProtoMessage()               {}
func (*MapStdTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{6} }

func (m *MapStdTypes) GetNullableTimestamp() map[int32]*time.Time {
	if m != nil {
		return m.NullableTimestamp
	}
	return nil
}

func (m *MapStdTypes) GetTimestamp() map[int32]time.Time {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *MapStdTypes) GetNullableDuration() map[int32]*time.Duration {
	if m != nil {
		return m.NullableDuration
	}
	return nil
}

func (m *MapStdTypes) GetDuration() map[int32]time.Duration {
	if m != nil {
		return m.Duration
	}
	return nil
}

type OneofProtoTypes struct {
	// Types that are valid to be assigned to OneOfProtoTimes:
	//	*OneofProtoTypes_Timestamp
	//	*OneofProtoTypes_Duration
	OneOfProtoTimes isOneofProtoTypes_OneOfProtoTimes `protobuf_oneof:"OneOfProtoTimes"`
}

func (m *OneofProtoTypes) Reset()                    { *m = OneofProtoTypes{} }
func (m *OneofProtoTypes) String() string            { return proto.CompactTextString(m) }
func (*OneofProtoTypes) ProtoMessage()               {}
func (*OneofProtoTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{7} }

type isOneofProtoTypes_OneOfProtoTimes interface {
	isOneofProtoTypes_OneOfProtoTimes()
	Equal(interface{}) bool
	VerboseEqual(interface{}) error
	MarshalTo([]byte) (int, error)
	Size() int
}

type OneofProtoTypes_Timestamp struct {
	Timestamp *google_protobuf2.Timestamp `protobuf:"bytes,1,opt,name=timestamp,oneof"`
}
type OneofProtoTypes_Duration struct {
	Duration *google_protobuf1.Duration `protobuf:"bytes,2,opt,name=duration,oneof"`
}

func (*OneofProtoTypes_Timestamp) isOneofProtoTypes_OneOfProtoTimes() {}
func (*OneofProtoTypes_Duration) isOneofProtoTypes_OneOfProtoTimes()  {}

func (m *OneofProtoTypes) GetOneOfProtoTimes() isOneofProtoTypes_OneOfProtoTimes {
	if m != nil {
		return m.OneOfProtoTimes
	}
	return nil
}

func (m *OneofProtoTypes) GetTimestamp() *google_protobuf2.Timestamp {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_Timestamp); ok {
		return x.Timestamp
	}
	return nil
}

func (m *OneofProtoTypes) GetDuration() *google_protobuf1.Duration {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_Duration); ok {
		return x.Duration
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*OneofProtoTypes) 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 _OneofProtoTypes_OneofMarshaler, _OneofProtoTypes_OneofUnmarshaler, _OneofProtoTypes_OneofSizer, []interface{}{
		(*OneofProtoTypes_Timestamp)(nil),
		(*OneofProtoTypes_Duration)(nil),
	}
}

func _OneofProtoTypes_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*OneofProtoTypes)
	// OneOfProtoTimes
	switch x := m.OneOfProtoTimes.(type) {
	case *OneofProtoTypes_Timestamp:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Timestamp); err != nil {
			return err
		}
	case *OneofProtoTypes_Duration:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Duration); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("OneofProtoTypes.OneOfProtoTimes has unexpected type %T", x)
	}
	return nil
}

func _OneofProtoTypes_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*OneofProtoTypes)
	switch tag {
	case 1: // OneOfProtoTimes.timestamp
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(google_protobuf2.Timestamp)
		err := b.DecodeMessage(msg)
		m.OneOfProtoTimes = &OneofProtoTypes_Timestamp{msg}
		return true, err
	case 2: // OneOfProtoTimes.duration
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(google_protobuf1.Duration)
		err := b.DecodeMessage(msg)
		m.OneOfProtoTimes = &OneofProtoTypes_Duration{msg}
		return true, err
	default:
		return false, nil
	}
}

func _OneofProtoTypes_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*OneofProtoTypes)
	// OneOfProtoTimes
	switch x := m.OneOfProtoTimes.(type) {
	case *OneofProtoTypes_Timestamp:
		s := proto.Size(x.Timestamp)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofProtoTypes_Duration:
		s := proto.Size(x.Duration)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type OneofStdTypes struct {
	// Types that are valid to be assigned to OneOfStdTimes:
	//	*OneofStdTypes_Timestamp
	//	*OneofStdTypes_Duration
	OneOfStdTimes isOneofStdTypes_OneOfStdTimes `protobuf_oneof:"OneOfStdTimes"`
}

func (m *OneofStdTypes) Reset()                    { *m = OneofStdTypes{} }
func (m *OneofStdTypes) String() string            { return proto.CompactTextString(m) }
func (*OneofStdTypes) ProtoMessage()               {}
func (*OneofStdTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{8} }

type isOneofStdTypes_OneOfStdTimes interface {
	isOneofStdTypes_OneOfStdTimes()
	Equal(interface{}) bool
	VerboseEqual(interface{}) error
	MarshalTo([]byte) (int, error)
	Size() int
}

type OneofStdTypes_Timestamp struct {
	Timestamp *time.Time `protobuf:"bytes,1,opt,name=timestamp,oneof,stdtime"`
}
type OneofStdTypes_Duration struct {
	Duration *time.Duration `protobuf:"bytes,2,opt,name=duration,oneof,stdduration"`
}

func (*OneofStdTypes_Timestamp) isOneofStdTypes_OneOfStdTimes() {}
func (*OneofStdTypes_Duration) isOneofStdTypes_OneOfStdTimes()  {}

func (m *OneofStdTypes) GetOneOfStdTimes() isOneofStdTypes_OneOfStdTimes {
	if m != nil {
		return m.OneOfStdTimes
	}
	return nil
}

func (m *OneofStdTypes) GetTimestamp() *time.Time {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_Timestamp); ok {
		return x.Timestamp
	}
	return nil
}

func (m *OneofStdTypes) GetDuration() *time.Duration {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_Duration); ok {
		return x.Duration
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*OneofStdTypes) 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 _OneofStdTypes_OneofMarshaler, _OneofStdTypes_OneofUnmarshaler, _OneofStdTypes_OneofSizer, []interface{}{
		(*OneofStdTypes_Timestamp)(nil),
		(*OneofStdTypes_Duration)(nil),
	}
}

func _OneofStdTypes_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*OneofStdTypes)
	// OneOfStdTimes
	switch x := m.OneOfStdTimes.(type) {
	case *OneofStdTypes_Timestamp:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdTimeMarshal(*x.Timestamp)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case *OneofStdTypes_Duration:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdDurationMarshal(*x.Duration)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("OneofStdTypes.OneOfStdTimes has unexpected type %T", x)
	}
	return nil
}

func _OneofStdTypes_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*OneofStdTypes)
	switch tag {
	case 1: // OneOfStdTimes.timestamp
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(time.Time)
		if err2 := github_com_gogo_protobuf_types.StdTimeUnmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_Timestamp{c}
		return true, err
	case 2: // OneOfStdTimes.duration
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(time.Duration)
		if err2 := github_com_gogo_protobuf_types.StdDurationUnmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_Duration{c}
		return true, err
	default:
		return false, nil
	}
}

func _OneofStdTypes_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*OneofStdTypes)
	// OneOfStdTimes
	switch x := m.OneOfStdTimes.(type) {
	case *OneofStdTypes_Timestamp:
		s := github_com_gogo_protobuf_types.SizeOfStdTime(*x.Timestamp)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_Duration:
		s := github_com_gogo_protobuf_types.SizeOfStdDuration(*x.Duration)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

func init() {
	proto.RegisterType((*KnownTypes)(nil), "types.KnownTypes")
	proto.RegisterType((*ProtoTypes)(nil), "types.ProtoTypes")
	proto.RegisterType((*StdTypes)(nil), "types.StdTypes")
	proto.RegisterType((*RepProtoTypes)(nil), "types.RepProtoTypes")
	proto.RegisterType((*RepStdTypes)(nil), "types.RepStdTypes")
	proto.RegisterType((*MapProtoTypes)(nil), "types.MapProtoTypes")
	proto.RegisterType((*MapStdTypes)(nil), "types.MapStdTypes")
	proto.RegisterType((*OneofProtoTypes)(nil), "types.OneofProtoTypes")
	proto.RegisterType((*OneofStdTypes)(nil), "types.OneofStdTypes")
}
func (this *KnownTypes) Compare(that interface{}) int {
	if that == nil {
		if this == nil {
			return 0
		}
		return 1
	}

	that1, ok := that.(*KnownTypes)
	if !ok {
		that2, ok := that.(KnownTypes)
		if ok {
			that1 = &that2
		} else {
			return 1
		}
	}
	if that1 == nil {
		if this == nil {
			return 0
		}
		return 1
	} else if this == nil {
		return -1
	}
	if c := this.Dur.Compare(that1.Dur); c != 0 {
		return c
	}
	if c := this.Ts.Compare(that1.Ts); c != 0 {
		return c
	}
	if c := this.Dbl.Compare(that1.Dbl); c != 0 {
		return c
	}
	if c := this.Flt.Compare(that1.Flt); c != 0 {
		return c
	}
	if c := this.I64.Compare(that1.I64); c != 0 {
		return c
	}
	if c := this.U64.Compare(that1.U64); c != 0 {
		return c
	}
	if c := this.I32.Compare(that1.I32); c != 0 {
		return c
	}
	if c := this.U32.Compare(that1.U32); c != 0 {
		return c
	}
	if c := this.Bool.Compare(that1.Bool); c != 0 {
		return c
	}
	if c := this.Str.Compare(that1.Str); c != 0 {
		return c
	}
	if c := this.Bytes.Compare(that1.Bytes); c != 0 {
		return c
	}
	return 0
}
func (this *ProtoTypes) Compare(that interface{}) int {
	if that == nil {
		if this == nil {
			return 0
		}
		return 1
	}

	that1, ok := that.(*ProtoTypes)
	if !ok {
		that2, ok := that.(ProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return 1
		}
	}
	if that1 == nil {
		if this == nil {
			return 0
		}
		return 1
	} else if this == nil {
		return -1
	}
	if c := this.NullableTimestamp.Compare(that1.NullableTimestamp); c != 0 {
		return c
	}
	if c := this.NullableDuration.Compare(that1.NullableDuration); c != 0 {
		return c
	}
	if c := this.Timestamp.Compare(&that1.Timestamp); c != 0 {
		return c
	}
	if c := this.Duration.Compare(&that1.Duration); c != 0 {
		return c
	}
	return 0
}
func (this *RepProtoTypes) Compare(that interface{}) int {
	if that == nil {
		if this == nil {
			return 0
		}
		return 1
	}

	that1, ok := that.(*RepProtoTypes)
	if !ok {
		that2, ok := that.(RepProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return 1
		}
	}
	if that1 == nil {
		if this == nil {
			return 0
		}
		return 1
	} else if this == nil {
		return -1
	}
	if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
		if len(this.NullableTimestamps) < len(that1.NullableTimestamps) {
			return -1
		}
		return 1
	}
	for i := range this.NullableTimestamps {
		if c := this.NullableTimestamps[i].Compare(that1.NullableTimestamps[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableDurations) != len(that1.NullableDurations) {
		if len(this.NullableDurations) < len(that1.NullableDurations) {
			return -1
		}
		return 1
	}
	for i := range this.NullableDurations {
		if c := this.NullableDurations[i].Compare(that1.NullableDurations[i]); c != 0 {
			return c
		}
	}
	if len(this.Timestamps) != len(that1.Timestamps) {
		if len(this.Timestamps) < len(that1.Timestamps) {
			return -1
		}
		return 1
	}
	for i := range this.Timestamps {
		if c := this.Timestamps[i].Compare(&that1.Timestamps[i]); c != 0 {
			return c
		}
	}
	if len(this.Durations) != len(that1.Durations) {
		if len(this.Durations) < len(that1.Durations) {
			return -1
		}
		return 1
	}
	for i := range this.Durations {
		if c := this.Durations[i].Compare(&that1.Durations[i]); c != 0 {
			return c
		}
	}
	return 0
}
func (this *KnownTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*KnownTypes)
	if !ok {
		that2, ok := that.(KnownTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *KnownTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *KnownTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *KnownTypes but is not nil && this == nil")
	}
	if !this.Dur.Equal(that1.Dur) {
		return fmt.Errorf("Dur this(%v) Not Equal that(%v)", this.Dur, that1.Dur)
	}
	if !this.Ts.Equal(that1.Ts) {
		return fmt.Errorf("Ts this(%v) Not Equal that(%v)", this.Ts, that1.Ts)
	}
	if !this.Dbl.Equal(that1.Dbl) {
		return fmt.Errorf("Dbl this(%v) Not Equal that(%v)", this.Dbl, that1.Dbl)
	}
	if !this.Flt.Equal(that1.Flt) {
		return fmt.Errorf("Flt this(%v) Not Equal that(%v)", this.Flt, that1.Flt)
	}
	if !this.I64.Equal(that1.I64) {
		return fmt.Errorf("I64 this(%v) Not Equal that(%v)", this.I64, that1.I64)
	}
	if !this.U64.Equal(that1.U64) {
		return fmt.Errorf("U64 this(%v) Not Equal that(%v)", this.U64, that1.U64)
	}
	if !this.I32.Equal(that1.I32) {
		return fmt.Errorf("I32 this(%v) Not Equal that(%v)", this.I32, that1.I32)
	}
	if !this.U32.Equal(that1.U32) {
		return fmt.Errorf("U32 this(%v) Not Equal that(%v)", this.U32, that1.U32)
	}
	if !this.Bool.Equal(that1.Bool) {
		return fmt.Errorf("Bool this(%v) Not Equal that(%v)", this.Bool, that1.Bool)
	}
	if !this.Str.Equal(that1.Str) {
		return fmt.Errorf("Str this(%v) Not Equal that(%v)", this.Str, that1.Str)
	}
	if !this.Bytes.Equal(that1.Bytes) {
		return fmt.Errorf("Bytes this(%v) Not Equal that(%v)", this.Bytes, that1.Bytes)
	}
	return nil
}
func (this *KnownTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*KnownTypes)
	if !ok {
		that2, ok := that.(KnownTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Dur.Equal(that1.Dur) {
		return false
	}
	if !this.Ts.Equal(that1.Ts) {
		return false
	}
	if !this.Dbl.Equal(that1.Dbl) {
		return false
	}
	if !this.Flt.Equal(that1.Flt) {
		return false
	}
	if !this.I64.Equal(that1.I64) {
		return false
	}
	if !this.U64.Equal(that1.U64) {
		return false
	}
	if !this.I32.Equal(that1.I32) {
		return false
	}
	if !this.U32.Equal(that1.U32) {
		return false
	}
	if !this.Bool.Equal(that1.Bool) {
		return false
	}
	if !this.Str.Equal(that1.Str) {
		return false
	}
	if !this.Bytes.Equal(that1.Bytes) {
		return false
	}
	return true
}
func (this *ProtoTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ProtoTypes)
	if !ok {
		that2, ok := that.(ProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *ProtoTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ProtoTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ProtoTypes but is not nil && this == nil")
	}
	if !this.NullableTimestamp.Equal(that1.NullableTimestamp) {
		return fmt.Errorf("NullableTimestamp this(%v) Not Equal that(%v)", this.NullableTimestamp, that1.NullableTimestamp)
	}
	if !this.NullableDuration.Equal(that1.NullableDuration) {
		return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", this.NullableDuration, that1.NullableDuration)
	}
	if !this.Timestamp.Equal(&that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", this.Timestamp, that1.Timestamp)
	}
	if !this.Duration.Equal(&that1.Duration) {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
	}
	return nil
}
func (this *ProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ProtoTypes)
	if !ok {
		that2, ok := that.(ProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.NullableTimestamp.Equal(that1.NullableTimestamp) {
		return false
	}
	if !this.NullableDuration.Equal(that1.NullableDuration) {
		return false
	}
	if !this.Timestamp.Equal(&that1.Timestamp) {
		return false
	}
	if !this.Duration.Equal(&that1.Duration) {
		return false
	}
	return true
}
func (this *StdTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StdTypes)
	if !ok {
		that2, ok := that.(StdTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StdTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StdTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StdTypes but is not nil && this == nil")
	}
	if that1.NullableTimestamp == nil {
		if this.NullableTimestamp != nil {
			return fmt.Errorf("this.NullableTimestamp != nil && that1.NullableTimestamp == nil")
		}
	} else if !this.NullableTimestamp.Equal(*that1.NullableTimestamp) {
		return fmt.Errorf("NullableTimestamp this(%v) Not Equal that(%v)", this.NullableTimestamp, that1.NullableTimestamp)
	}
	if this.NullableDuration != nil && that1.NullableDuration != nil {
		if *this.NullableDuration != *that1.NullableDuration {
			return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", *this.NullableDuration, *that1.NullableDuration)
		}
	} else if this.NullableDuration != nil {
		return fmt.Errorf("this.NullableDuration == nil && that.NullableDuration != nil")
	} else if that1.NullableDuration != nil {
		return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", this.NullableDuration, that1.NullableDuration)
	}
	if !this.Timestamp.Equal(that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", this.Timestamp, that1.Timestamp)
	}
	if this.Duration != that1.Duration {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
	}
	return nil
}
func (this *StdTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*StdTypes)
	if !ok {
		that2, ok := that.(StdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.NullableTimestamp == nil {
		if this.NullableTimestamp != nil {
			return false
		}
	} else if !this.NullableTimestamp.Equal(*that1.NullableTimestamp) {
		return false
	}
	if this.NullableDuration != nil && that1.NullableDuration != nil {
		if *this.NullableDuration != *that1.NullableDuration {
			return false
		}
	} else if this.NullableDuration != nil {
		return false
	} else if that1.NullableDuration != nil {
		return false
	}
	if !this.Timestamp.Equal(that1.Timestamp) {
		return false
	}
	if this.Duration != that1.Duration {
		return false
	}
	return true
}
func (this *RepProtoTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*RepProtoTypes)
	if !ok {
		that2, ok := that.(RepProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *RepProtoTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *RepProtoTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *RepProtoTypes but is not nil && this == nil")
	}
	if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
		return fmt.Errorf("NullableTimestamps this(%v) Not Equal that(%v)", len(this.NullableTimestamps), len(that1.NullableTimestamps))
	}
	for i := range this.NullableTimestamps {
		if !this.NullableTimestamps[i].Equal(that1.NullableTimestamps[i]) {
			return fmt.Errorf("NullableTimestamps this[%v](%v) Not Equal that[%v](%v)", i, this.NullableTimestamps[i], i, that1.NullableTimestamps[i])
		}
	}
	if len(this.NullableDurations) != len(that1.NullableDurations) {
		return fmt.Errorf("NullableDurations this(%v) Not Equal that(%v)", len(this.NullableDurations), len(that1.NullableDurations))
	}
	for i := range this.NullableDurations {
		if !this.NullableDurations[i].Equal(that1.NullableDurations[i]) {
			return fmt.Errorf("NullableDurations this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDurations[i], i, that1.NullableDurations[i])
		}
	}
	if len(this.Timestamps) != len(that1.Timestamps) {
		return fmt.Errorf("Timestamps this(%v) Not Equal that(%v)", len(this.Timestamps), len(that1.Timestamps))
	}
	for i := range this.Timestamps {
		if !this.Timestamps[i].Equal(&that1.Timestamps[i]) {
			return fmt.Errorf("Timestamps this[%v](%v) Not Equal that[%v](%v)", i, this.Timestamps[i], i, that1.Timestamps[i])
		}
	}
	if len(this.Durations) != len(that1.Durations) {
		return fmt.Errorf("Durations this(%v) Not Equal that(%v)", len(this.Durations), len(that1.Durations))
	}
	for i := range this.Durations {
		if !this.Durations[i].Equal(&that1.Durations[i]) {
			return fmt.Errorf("Durations this[%v](%v) Not Equal that[%v](%v)", i, this.Durations[i], i, that1.Durations[i])
		}
	}
	return nil
}
func (this *RepProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RepProtoTypes)
	if !ok {
		that2, ok := that.(RepProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
		return false
	}
	for i := range this.NullableTimestamps {
		if !this.NullableTimestamps[i].Equal(that1.NullableTimestamps[i]) {
			return false
		}
	}
	if len(this.NullableDurations) != len(that1.NullableDurations) {
		return false
	}
	for i := range this.NullableDurations {
		if !this.NullableDurations[i].Equal(that1.NullableDurations[i]) {
			return false
		}
	}
	if len(this.Timestamps) != len(that1.Timestamps) {
		return false
	}
	for i := range this.Timestamps {
		if !this.Timestamps[i].Equal(&that1.Timestamps[i]) {
			return false
		}
	}
	if len(this.Durations) != len(that1.Durations) {
		return false
	}
	for i := range this.Durations {
		if !this.Durations[i].Equal(&that1.Durations[i]) {
			return false
		}
	}
	return true
}
func (this *RepStdTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*RepStdTypes)
	if !ok {
		that2, ok := that.(RepStdTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *RepStdTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *RepStdTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *RepStdTypes but is not nil && this == nil")
	}
	if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
		return fmt.Errorf("NullableTimestamps this(%v) Not Equal that(%v)", len(this.NullableTimestamps), len(that1.NullableTimestamps))
	}
	for i := range this.NullableTimestamps {
		if !this.NullableTimestamps[i].Equal(*that1.NullableTimestamps[i]) {
			return fmt.Errorf("NullableTimestamps this[%v](%v) Not Equal that[%v](%v)", i, this.NullableTimestamps[i], i, that1.NullableTimestamps[i])
		}
	}
	if len(this.NullableDurations) != len(that1.NullableDurations) {
		return fmt.Errorf("NullableDurations this(%v) Not Equal that(%v)", len(this.NullableDurations), len(that1.NullableDurations))
	}
	for i := range this.NullableDurations {
		if dthis, dthat := this.NullableDurations[i], that1.NullableDurations[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableDurations this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDurations[i], i, that1.NullableDurations[i])
		}
	}
	if len(this.Timestamps) != len(that1.Timestamps) {
		return fmt.Errorf("Timestamps this(%v) Not Equal that(%v)", len(this.Timestamps), len(that1.Timestamps))
	}
	for i := range this.Timestamps {
		if !this.Timestamps[i].Equal(that1.Timestamps[i]) {
			return fmt.Errorf("Timestamps this[%v](%v) Not Equal that[%v](%v)", i, this.Timestamps[i], i, that1.Timestamps[i])
		}
	}
	if len(this.Durations) != len(that1.Durations) {
		return fmt.Errorf("Durations this(%v) Not Equal that(%v)", len(this.Durations), len(that1.Durations))
	}
	for i := range this.Durations {
		if this.Durations[i] != that1.Durations[i] {
			return fmt.Errorf("Durations this[%v](%v) Not Equal that[%v](%v)", i, this.Durations[i], i, that1.Durations[i])
		}
	}
	return nil
}
func (this *RepStdTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RepStdTypes)
	if !ok {
		that2, ok := that.(RepStdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
		return false
	}
	for i := range this.NullableTimestamps {
		if !this.NullableTimestamps[i].Equal(*that1.NullableTimestamps[i]) {
			return false
		}
	}
	if len(this.NullableDurations) != len(that1.NullableDurations) {
		return false
	}
	for i := range this.NullableDurations {
		if dthis, dthat := this.NullableDurations[i], that1.NullableDurations[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.Timestamps) != len(that1.Timestamps) {
		return false
	}
	for i := range this.Timestamps {
		if !this.Timestamps[i].Equal(that1.Timestamps[i]) {
			return false
		}
	}
	if len(this.Durations) != len(that1.Durations) {
		return false
	}
	for i := range this.Durations {
		if this.Durations[i] != that1.Durations[i] {
			return false
		}
	}
	return true
}
func (this *MapProtoTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*MapProtoTypes)
	if !ok {
		that2, ok := that.(MapProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *MapProtoTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *MapProtoTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *MapProtoTypes but is not nil && this == nil")
	}
	if len(this.NullableTimestamp) != len(that1.NullableTimestamp) {
		return fmt.Errorf("NullableTimestamp this(%v) Not Equal that(%v)", len(this.NullableTimestamp), len(that1.NullableTimestamp))
	}
	for i := range this.NullableTimestamp {
		if !this.NullableTimestamp[i].Equal(that1.NullableTimestamp[i]) {
			return fmt.Errorf("NullableTimestamp this[%v](%v) Not Equal that[%v](%v)", i, this.NullableTimestamp[i], i, that1.NullableTimestamp[i])
		}
	}
	if len(this.Timestamp) != len(that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", len(this.Timestamp), len(that1.Timestamp))
	}
	for i := range this.Timestamp {
		a := this.Timestamp[i]
		b := that1.Timestamp[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("Timestamp this[%v](%v) Not Equal that[%v](%v)", i, this.Timestamp[i], i, that1.Timestamp[i])
		}
	}
	if len(this.NullableDuration) != len(that1.NullableDuration) {
		return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", len(this.NullableDuration), len(that1.NullableDuration))
	}
	for i := range this.NullableDuration {
		if !this.NullableDuration[i].Equal(that1.NullableDuration[i]) {
			return fmt.Errorf("NullableDuration this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDuration[i], i, that1.NullableDuration[i])
		}
	}
	if len(this.Duration) != len(that1.Duration) {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", len(this.Duration), len(that1.Duration))
	}
	for i := range this.Duration {
		a := this.Duration[i]
		b := that1.Duration[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("Duration this[%v](%v) Not Equal that[%v](%v)", i, this.Duration[i], i, that1.Duration[i])
		}
	}
	return nil
}
func (this *MapProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MapProtoTypes)
	if !ok {
		that2, ok := that.(MapProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NullableTimestamp) != len(that1.NullableTimestamp) {
		return false
	}
	for i := range this.NullableTimestamp {
		if !this.NullableTimestamp[i].Equal(that1.NullableTimestamp[i]) {
			return false
		}
	}
	if len(this.Timestamp) != len(that1.Timestamp) {
		return false
	}
	for i := range this.Timestamp {
		a := this.Timestamp[i]
		b := that1.Timestamp[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableDuration) != len(that1.NullableDuration) {
		return false
	}
	for i := range this.NullableDuration {
		if !this.NullableDuration[i].Equal(that1.NullableDuration[i]) {
			return false
		}
	}
	if len(this.Duration) != len(that1.Duration) {
		return false
	}
	for i := range this.Duration {
		a := this.Duration[i]
		b := that1.Duration[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	return true
}
func (this *MapStdTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*MapStdTypes)
	if !ok {
		that2, ok := that.(MapStdTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *MapStdTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *MapStdTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *MapStdTypes but is not nil && this == nil")
	}
	if len(this.NullableTimestamp) != len(that1.NullableTimestamp) {
		return fmt.Errorf("NullableTimestamp this(%v) Not Equal that(%v)", len(this.NullableTimestamp), len(that1.NullableTimestamp))
	}
	for i := range this.NullableTimestamp {
		if !this.NullableTimestamp[i].Equal(*that1.NullableTimestamp[i]) {
			return fmt.Errorf("NullableTimestamp this[%v](%v) Not Equal that[%v](%v)", i, this.NullableTimestamp[i], i, that1.NullableTimestamp[i])
		}
	}
	if len(this.Timestamp) != len(that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", len(this.Timestamp), len(that1.Timestamp))
	}
	for i := range this.Timestamp {
		if !this.Timestamp[i].Equal(that1.Timestamp[i]) {
			return fmt.Errorf("Timestamp this[%v](%v) Not Equal that[%v](%v)", i, this.Timestamp[i], i, that1.Timestamp[i])
		}
	}
	if len(this.NullableDuration) != len(that1.NullableDuration) {
		return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", len(this.NullableDuration), len(that1.NullableDuration))
	}
	for i := range this.NullableDuration {
		if dthis, dthat := this.NullableDuration[i], that1.NullableDuration[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableDuration this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDuration[i], i, that1.NullableDuration[i])
		}
	}
	if len(this.Duration) != len(that1.Duration) {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", len(this.Duration), len(that1.Duration))
	}
	for i := range this.Duration {
		if this.Duration[i] != that1.Duration[i] {
			return fmt.Errorf("Duration this[%v](%v) Not Equal that[%v](%v)", i, this.Duration[i], i, that1.Duration[i])
		}
	}
	return nil
}
func (this *MapStdTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MapStdTypes)
	if !ok {
		that2, ok := that.(MapStdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NullableTimestamp) != len(that1.NullableTimestamp) {
		return false
	}
	for i := range this.NullableTimestamp {
		if !this.NullableTimestamp[i].Equal(*that1.NullableTimestamp[i]) {
			return false
		}
	}
	if len(this.Timestamp) != len(that1.Timestamp) {
		return false
	}
	for i := range this.Timestamp {
		if !this.Timestamp[i].Equal(that1.Timestamp[i]) {
			return false
		}
	}
	if len(this.NullableDuration) != len(that1.NullableDuration) {
		return false
	}
	for i := range this.NullableDuration {
		if dthis, dthat := this.NullableDuration[i], that1.NullableDuration[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.Duration) != len(that1.Duration) {
		return false
	}
	for i := range this.Duration {
		if this.Duration[i] != that1.Duration[i] {
			return false
		}
	}
	return true
}
func (this *OneofProtoTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes)
	if !ok {
		that2, ok := that.(OneofProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes but is not nil && this == nil")
	}
	if that1.OneOfProtoTimes == nil {
		if this.OneOfProtoTimes != nil {
			return fmt.Errorf("this.OneOfProtoTimes != nil && that1.OneOfProtoTimes == nil")
		}
	} else if this.OneOfProtoTimes == nil {
		return fmt.Errorf("this.OneOfProtoTimes == nil && that1.OneOfProtoTimes != nil")
	} else if err := this.OneOfProtoTimes.VerboseEqual(that1.OneOfProtoTimes); err != nil {
		return err
	}
	return nil
}
func (this *OneofProtoTypes_Timestamp) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_Timestamp)
	if !ok {
		that2, ok := that.(OneofProtoTypes_Timestamp)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_Timestamp")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_Timestamp but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_Timestamp but is not nil && this == nil")
	}
	if !this.Timestamp.Equal(that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", this.Timestamp, that1.Timestamp)
	}
	return nil
}
func (this *OneofProtoTypes_Duration) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_Duration)
	if !ok {
		that2, ok := that.(OneofProtoTypes_Duration)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_Duration")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_Duration but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_Duration but is not nil && this == nil")
	}
	if !this.Duration.Equal(that1.Duration) {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
	}
	return nil
}
func (this *OneofProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OneofProtoTypes)
	if !ok {
		that2, ok := that.(OneofProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.OneOfProtoTimes == nil {
		if this.OneOfProtoTimes != nil {
			return false
		}
	} else if this.OneOfProtoTimes == nil {
		return false
	} else if !this.OneOfProtoTimes.Equal(that1.OneOfProtoTimes) {
		return false
	}
	return true
}
func (this *OneofProtoTypes_Timestamp) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OneofProtoTypes_Timestamp)
	if !ok {
		that2, ok := that.(OneofProtoTypes_Timestamp)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Timestamp.Equal(that1.Timestamp) {
		return false
	}
	return true
}
func (this *OneofProtoTypes_Duration) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OneofProtoTypes_Duration)
	if !ok {
		that2, ok := that.(OneofProtoTypes_Duration)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Duration.Equal(that1.Duration) {
		return false
	}
	return true
}
func (this *OneofStdTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes)
	if !ok {
		that2, ok := that.(OneofStdTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes but is not nil && this == nil")
	}
	if that1.OneOfStdTimes == nil {
		if this.OneOfStdTimes != nil {
			return fmt.Errorf("this.OneOfStdTimes != nil && that1.OneOfStdTimes == nil")
		}
	} else if this.OneOfStdTimes == nil {
		return fmt.Errorf("this.OneOfStdTimes == nil && that1.OneOfStdTimes != nil")
	} else if err := this.OneOfStdTimes.VerboseEqual(that1.OneOfStdTimes); err != nil {
		return err
	}
	return nil
}
func (this *OneofStdTypes_Timestamp) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_Timestamp)
	if !ok {
		that2, ok := that.(OneofStdTypes_Timestamp)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_Timestamp")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_Timestamp but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_Timestamp but is not nil && this == nil")
	}
	if that1.Timestamp == nil {
		if this.Timestamp != nil {
			return fmt.Errorf("this.Timestamp != nil && that1.Timestamp == nil")
		}
	} else if !this.Timestamp.Equal(*that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", this.Timestamp, that1.Timestamp)
	}
	return nil
}
func (this *OneofStdTypes_Duration) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_Duration)
	if !ok {
		that2, ok := that.(OneofStdTypes_Duration)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_Duration")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_Duration but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_Duration but is not nil && this == nil")
	}
	if this.Duration != nil && that1.Duration != nil {
		if *this.Duration != *that1.Duration {
			return fmt.Errorf("Duration this(%v) Not Equal that(%v)", *this.Duration, *that1.Duration)
		}
	} else if this.Duration != nil {
		return fmt.Errorf("this.Duration == nil && that.Duration != nil")
	} else if that1.Duration != nil {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
	}
	return nil
}
func (this *OneofStdTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OneofStdTypes)
	if !ok {
		that2, ok := that.(OneofStdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.OneOfStdTimes == nil {
		if this.OneOfStdTimes != nil {
			return false
		}
	} else if this.OneOfStdTimes == nil {
		return false
	} else if !this.OneOfStdTimes.Equal(that1.OneOfStdTimes) {
		return false
	}
	return true
}
func (this *OneofStdTypes_Timestamp) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OneofStdTypes_Timestamp)
	if !ok {
		that2, ok := that.(OneofStdTypes_Timestamp)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Timestamp == nil {
		if this.Timestamp != nil {
			return false
		}
	} else if !this.Timestamp.Equal(*that1.Timestamp) {
		return false
	}
	return true
}
func (this *OneofStdTypes_Duration) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OneofStdTypes_Duration)
	if !ok {
		that2, ok := that.(OneofStdTypes_Duration)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Duration != nil && that1.Duration != nil {
		if *this.Duration != *that1.Duration {
			return false
		}
	} else if this.Duration != nil {
		return false
	} else if that1.Duration != nil {
		return false
	}
	return true
}
func (m *KnownTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *KnownTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Dur != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Dur.Size()))
		n1, err := m.Dur.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.Ts != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Ts.Size()))
		n2, err := m.Ts.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Dbl != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Dbl.Size()))
		n3, err := m.Dbl.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Flt != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Flt.Size()))
		n4, err := m.Flt.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.I64 != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.I64.Size()))
		n5, err := m.I64.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.U64 != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.U64.Size()))
		n6, err := m.U64.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.I32 != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.I32.Size()))
		n7, err := m.I32.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.U32 != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.U32.Size()))
		n8, err := m.U32.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.Bool != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Bool.Size()))
		n9, err := m.Bool.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.Str != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Str.Size()))
		n10, err := m.Str.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if m.Bytes != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Bytes.Size()))
		n11, err := m.Bytes.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}

func (m *ProtoTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ProtoTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.NullableTimestamp != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.NullableTimestamp.Size()))
		n12, err := m.NullableTimestamp.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.NullableDuration != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.NullableDuration.Size()))
		n13, err := m.NullableDuration.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintTypes(dAtA, i, uint64(m.Timestamp.Size()))
	n14, err := m.Timestamp.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n14
	dAtA[i] = 0x22
	i++
	i = encodeVarintTypes(dAtA, i, uint64(m.Duration.Size()))
	n15, err := m.Duration.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n15
	return i, nil
}

func (m *StdTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StdTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.NullableTimestamp != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdTime(*m.NullableTimestamp)))
		n16, err := types1.StdTimeMarshalTo(*m.NullableTimestamp, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	if m.NullableDuration != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdDuration(*m.NullableDuration)))
		n17, err := types1.StdDurationMarshalTo(*m.NullableDuration, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdTime(m.Timestamp)))
	n18, err := types1.StdTimeMarshalTo(m.Timestamp, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n18
	dAtA[i] = 0x22
	i++
	i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdDuration(m.Duration)))
	n19, err := types1.StdDurationMarshalTo(m.Duration, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n19
	return i, nil
}

func (m *RepProtoTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RepProtoTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NullableTimestamps) > 0 {
		for _, msg := range m.NullableTimestamps {
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.NullableDurations) > 0 {
		for _, msg := range m.NullableDurations {
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Timestamps) > 0 {
		for _, msg := range m.Timestamps {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Durations) > 0 {
		for _, msg := range m.Durations {
			dAtA[i] = 0x22
			i++
			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *RepStdTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RepStdTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NullableTimestamps) > 0 {
		for _, msg := range m.NullableTimestamps {
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdTime(*msg)))
			n, err := types1.StdTimeMarshalTo(*msg, dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.NullableDurations) > 0 {
		for _, msg := range m.NullableDurations {
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdDuration(*msg)))
			n, err := types1.StdDurationMarshalTo(*msg, dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Timestamps) > 0 {
		for _, msg := range m.Timestamps {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdTime(msg)))
			n, err := types1.StdTimeMarshalTo(msg, dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Durations) > 0 {
		for _, msg := range m.Durations {
			dAtA[i] = 0x22
			i++
			i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdDuration(msg)))
			n, err := types1.StdDurationMarshalTo(msg, dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *MapProtoTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MapProtoTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NullableTimestamp) > 0 {
		for k := range m.NullableTimestamp {
			dAtA[i] = 0xa
			i++
			v := m.NullableTimestamp[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(v.Size()))
				n20, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n20
			}
		}
	}
	if len(m.Timestamp) > 0 {
		for k := range m.Timestamp {
			dAtA[i] = 0x12
			i++
			v := m.Timestamp[k]
			msgSize := 0
			if (&v) != nil {
				msgSize = (&v).Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64((&v).Size()))
			n21, err := (&v).MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n21
		}
	}
	if len(m.NullableDuration) > 0 {
		for k := range m.NullableDuration {
			dAtA[i] = 0x1a
			i++
			v := m.NullableDuration[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(v.Size()))
				n22, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n22
			}
		}
	}
	if len(m.Duration) > 0 {
		for k := range m.Duration {
			dAtA[i] = 0x22
			i++
			v := m.Duration[k]
			msgSize := 0
			if (&v) != nil {
				msgSize = (&v).Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64((&v).Size()))
			n23, err := (&v).MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n23
		}
	}
	return i, nil
}

func (m *MapStdTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MapStdTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NullableTimestamp) > 0 {
		for k := range m.NullableTimestamp {
			dAtA[i] = 0xa
			i++
			v := m.NullableTimestamp[k]
			msgSize := 0
			if v != nil {
				msgSize = types1.SizeOfStdTime(*v)
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdTime(*v)))
				n24, err := types1.StdTimeMarshalTo(*v, dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n24
			}
		}
	}
	if len(m.Timestamp) > 0 {
		for k := range m.Timestamp {
			dAtA[i] = 0x12
			i++
			v := m.Timestamp[k]
			msgSize := 0
			if (&v) != nil {
				msgSize = types1.SizeOfStdTime(*(&v))
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdTime(*(&v))))
			n25, err := types1.StdTimeMarshalTo(*(&v), dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n25
		}
	}
	if len(m.NullableDuration) > 0 {
		for k := range m.NullableDuration {
			dAtA[i] = 0x1a
			i++
			v := m.NullableDuration[k]
			msgSize := 0
			if v != nil {
				msgSize = types1.SizeOfStdDuration(*v)
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdDuration(*v)))
				n26, err := types1.StdDurationMarshalTo(*v, dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n26
			}
		}
	}
	if len(m.Duration) > 0 {
		for k := range m.Duration {
			dAtA[i] = 0x22
			i++
			v := m.Duration[k]
			msgSize := 0
			if (&v) != nil {
				msgSize = types1.SizeOfStdDuration(*(&v))
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdDuration(*(&v))))
			n27, err := types1.StdDurationMarshalTo(*(&v), dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n27
		}
	}
	return i, nil
}

func (m *OneofProtoTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OneofProtoTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OneOfProtoTimes != nil {
		nn28, err := m.OneOfProtoTimes.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn28
	}
	return i, nil
}

func (m *OneofProtoTypes_Timestamp) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Timestamp != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Timestamp.Size()))
		n29, err := m.Timestamp.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n29
	}
	return i, nil
}
func (m *OneofProtoTypes_Duration) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Duration != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Duration.Size()))
		n30, err := m.Duration.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n30
	}
	return i, nil
}
func (m *OneofStdTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OneofStdTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OneOfStdTimes != nil {
		nn31, err := m.OneOfStdTimes.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn31
	}
	return i, nil
}

func (m *OneofStdTypes_Timestamp) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Timestamp != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdTime(*m.Timestamp)))
		n32, err := types1.StdTimeMarshalTo(*m.Timestamp, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n32
	}
	return i, nil
}
func (m *OneofStdTypes_Duration) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Duration != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTypes(dAtA, i, uint64(types1.SizeOfStdDuration(*m.Duration)))
		n33, err := types1.StdDurationMarshalTo(*m.Duration, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n33
	}
	return i, nil
}
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func NewPopulatedKnownTypes(r randyTypes, easy bool) *KnownTypes {
	this := &KnownTypes{}
	if r.Intn(10) != 0 {
		this.Dur = google_protobuf1.NewPopulatedDuration(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Ts = google_protobuf2.NewPopulatedTimestamp(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Dbl = google_protobuf3.NewPopulatedDoubleValue(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Flt = google_protobuf3.NewPopulatedFloatValue(r, easy)
	}
	if r.Intn(10) != 0 {
		this.I64 = google_protobuf3.NewPopulatedInt64Value(r, easy)
	}
	if r.Intn(10) != 0 {
		this.U64 = google_protobuf3.NewPopulatedUInt64Value(r, easy)
	}
	if r.Intn(10) != 0 {
		this.I32 = google_protobuf3.NewPopulatedInt32Value(r, easy)
	}
	if r.Intn(10) != 0 {
		this.U32 = google_protobuf3.NewPopulatedUInt32Value(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Bool = google_protobuf3.NewPopulatedBoolValue(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Str = google_protobuf3.NewPopulatedStringValue(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Bytes = google_protobuf3.NewPopulatedBytesValue(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedProtoTypes(r randyTypes, easy bool) *ProtoTypes {
	this := &ProtoTypes{}
	if r.Intn(10) != 0 {
		this.NullableTimestamp = google_protobuf2.NewPopulatedTimestamp(r, easy)
	}
	if r.Intn(10) != 0 {
		this.NullableDuration = google_protobuf1.NewPopulatedDuration(r, easy)
	}
	v1 := google_protobuf2.NewPopulatedTimestamp(r, easy)
	this.Timestamp = *v1
	v2 := google_protobuf1.NewPopulatedDuration(r, easy)
	this.Duration = *v2
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedStdTypes(r randyTypes, easy bool) *StdTypes {
	this := &StdTypes{}
	if r.Intn(10) != 0 {
		this.NullableTimestamp = types1.NewPopulatedStdTime(r, easy)
	}
	if r.Intn(10) != 0 {
		this.NullableDuration = types1.NewPopulatedStdDuration(r, easy)
	}
	v3 := types1.NewPopulatedStdTime(r, easy)
	this.Timestamp = *v3
	v4 := types1.NewPopulatedStdDuration(r, easy)
	this.Duration = *v4
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRepProtoTypes(r randyTypes, easy bool) *RepProtoTypes {
	this := &RepProtoTypes{}
	if r.Intn(10) != 0 {
		v5 := r.Intn(5)
		this.NullableTimestamps = make([]*google_protobuf2.Timestamp, v5)
		for i := 0; i < v5; i++ {
			this.NullableTimestamps[i] = google_protobuf2.NewPopulatedTimestamp(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v6 := r.Intn(5)
		this.NullableDurations = make([]*google_protobuf1.Duration, v6)
		for i := 0; i < v6; i++ {
			this.NullableDurations[i] = google_protobuf1.NewPopulatedDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v7 := r.Intn(5)
		this.Timestamps = make([]google_protobuf2.Timestamp, v7)
		for i := 0; i < v7; i++ {
			v8 := google_protobuf2.NewPopulatedTimestamp(r, easy)
			this.Timestamps[i] = *v8
		}
	}
	if r.Intn(10) != 0 {
		v9 := r.Intn(5)
		this.Durations = make([]google_protobuf1.Duration, v9)
		for i := 0; i < v9; i++ {
			v10 := google_protobuf1.NewPopulatedDuration(r, easy)
			this.Durations[i] = *v10
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRepStdTypes(r randyTypes, easy bool) *RepStdTypes {
	this := &RepStdTypes{}
	if r.Intn(10) != 0 {
		v11 := r.Intn(5)
		this.NullableTimestamps = make([]*time.Time, v11)
		for i := 0; i < v11; i++ {
			this.NullableTimestamps[i] = types1.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v12 := r.Intn(5)
		this.NullableDurations = make([]*time.Duration, v12)
		for i := 0; i < v12; i++ {
			this.NullableDurations[i] = types1.NewPopulatedStdDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v13 := r.Intn(5)
		this.Timestamps = make([]time.Time, v13)
		for i := 0; i < v13; i++ {
			v14 := types1.NewPopulatedStdTime(r, easy)
			this.Timestamps[i] = *v14
		}
	}
	if r.Intn(10) != 0 {
		v15 := r.Intn(5)
		this.Durations = make([]time.Duration, v15)
		for i := 0; i < v15; i++ {
			v16 := types1.NewPopulatedStdDuration(r, easy)
			this.Durations[i] = *v16
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedMapProtoTypes(r randyTypes, easy bool) *MapProtoTypes {
	this := &MapProtoTypes{}
	if r.Intn(10) != 0 {
		v17 := r.Intn(10)
		this.NullableTimestamp = make(map[int32]*google_protobuf2.Timestamp)
		for i := 0; i < v17; i++ {
			this.NullableTimestamp[int32(r.Int31())] = google_protobuf2.NewPopulatedTimestamp(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v18 := r.Intn(10)
		this.Timestamp = make(map[int32]google_protobuf2.Timestamp)
		for i := 0; i < v18; i++ {
			this.Timestamp[int32(r.Int31())] = *google_protobuf2.NewPopulatedTimestamp(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v19 := r.Intn(10)
		this.NullableDuration = make(map[int32]*google_protobuf1.Duration)
		for i := 0; i < v19; i++ {
			this.NullableDuration[int32(r.Int31())] = google_protobuf1.NewPopulatedDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v20 := r.Intn(10)
		this.Duration = make(map[int32]google_protobuf1.Duration)
		for i := 0; i < v20; i++ {
			this.Duration[int32(r.Int31())] = *google_protobuf1.NewPopulatedDuration(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedMapStdTypes(r randyTypes, easy bool) *MapStdTypes {
	this := &MapStdTypes{}
	if r.Intn(10) != 0 {
		v21 := r.Intn(10)
		this.NullableTimestamp = make(map[int32]*time.Time)
		for i := 0; i < v21; i++ {
			this.NullableTimestamp[int32(r.Int31())] = types1.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v22 := r.Intn(10)
		this.Timestamp = make(map[int32]time.Time)
		for i := 0; i < v22; i++ {
			this.Timestamp[int32(r.Int31())] = *types1.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v23 := r.Intn(10)
		this.NullableDuration = make(map[int32]*time.Duration)
		for i := 0; i < v23; i++ {
			this.NullableDuration[int32(r.Int31())] = types1.NewPopulatedStdDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v24 := r.Intn(10)
		this.Duration = make(map[int32]time.Duration)
		for i := 0; i < v24; i++ {
			this.Duration[int32(r.Int31())] = *types1.NewPopulatedStdDuration(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedOneofProtoTypes(r randyTypes, easy bool) *OneofProtoTypes {
	this := &OneofProtoTypes{}
	oneofNumber_OneOfProtoTimes := []int32{1, 2}[r.Intn(2)]
	switch oneofNumber_OneOfProtoTimes {
	case 1:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_Timestamp(r, easy)
	case 2:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_Duration(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedOneofProtoTypes_Timestamp(r randyTypes, easy bool) *OneofProtoTypes_Timestamp {
	this := &OneofProtoTypes_Timestamp{}
	this.Timestamp = google_protobuf2.NewPopulatedTimestamp(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_Duration(r randyTypes, easy bool) *OneofProtoTypes_Duration {
	this := &OneofProtoTypes_Duration{}
	this.Duration = google_protobuf1.NewPopulatedDuration(r, easy)
	return this
}
func NewPopulatedOneofStdTypes(r randyTypes, easy bool) *OneofStdTypes {
	this := &OneofStdTypes{}
	oneofNumber_OneOfStdTimes := []int32{1, 2}[r.Intn(2)]
	switch oneofNumber_OneOfStdTimes {
	case 1:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_Timestamp(r, easy)
	case 2:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_Duration(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedOneofStdTypes_Timestamp(r randyTypes, easy bool) *OneofStdTypes_Timestamp {
	this := &OneofStdTypes_Timestamp{}
	this.Timestamp = types1.NewPopulatedStdTime(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_Duration(r randyTypes, easy bool) *OneofStdTypes_Duration {
	this := &OneofStdTypes_Duration{}
	this.Duration = types1.NewPopulatedStdDuration(r, easy)
	return this
}

type randyTypes interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneTypes(r randyTypes) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringTypes(r randyTypes) string {
	v25 := r.Intn(100)
	tmps := make([]rune, v25)
	for i := 0; i < v25; i++ {
		tmps[i] = randUTF8RuneTypes(r)
	}
	return string(tmps)
}
func randUnrecognizedTypes(r randyTypes, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldTypes(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldTypes(dAtA []byte, r randyTypes, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
		v26 := r.Int63()
		if r.Intn(2) == 0 {
			v26 *= -1
		}
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(v26))
	case 1:
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateTypes(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *KnownTypes) Size() (n int) {
	var l int
	_ = l
	if m.Dur != nil {
		l = m.Dur.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Ts != nil {
		l = m.Ts.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Dbl != nil {
		l = m.Dbl.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Flt != nil {
		l = m.Flt.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.I64 != nil {
		l = m.I64.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.U64 != nil {
		l = m.U64.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.I32 != nil {
		l = m.I32.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.U32 != nil {
		l = m.U32.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Bool != nil {
		l = m.Bool.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Str != nil {
		l = m.Str.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Bytes != nil {
		l = m.Bytes.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *ProtoTypes) Size() (n int) {
	var l int
	_ = l
	if m.NullableTimestamp != nil {
		l = m.NullableTimestamp.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableDuration != nil {
		l = m.NullableDuration.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Timestamp.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.Duration.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *StdTypes) Size() (n int) {
	var l int
	_ = l
	if m.NullableTimestamp != nil {
		l = types1.SizeOfStdTime(*m.NullableTimestamp)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableDuration != nil {
		l = types1.SizeOfStdDuration(*m.NullableDuration)
		n += 1 + l + sovTypes(uint64(l))
	}
	l = types1.SizeOfStdTime(m.Timestamp)
	n += 1 + l + sovTypes(uint64(l))
	l = types1.SizeOfStdDuration(m.Duration)
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *RepProtoTypes) Size() (n int) {
	var l int
	_ = l
	if len(m.NullableTimestamps) > 0 {
		for _, e := range m.NullableTimestamps {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableDurations) > 0 {
		for _, e := range m.NullableDurations {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Timestamps) > 0 {
		for _, e := range m.Timestamps {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Durations) > 0 {
		for _, e := range m.Durations {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *RepStdTypes) Size() (n int) {
	var l int
	_ = l
	if len(m.NullableTimestamps) > 0 {
		for _, e := range m.NullableTimestamps {
			l = types1.SizeOfStdTime(*e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableDurations) > 0 {
		for _, e := range m.NullableDurations {
			l = types1.SizeOfStdDuration(*e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Timestamps) > 0 {
		for _, e := range m.Timestamps {
			l = types1.SizeOfStdTime(e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Durations) > 0 {
		for _, e := range m.Durations {
			l = types1.SizeOfStdDuration(e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *MapProtoTypes) Size() (n int) {
	var l int
	_ = l
	if len(m.NullableTimestamp) > 0 {
		for k, v := range m.NullableTimestamp {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.Timestamp) > 0 {
		for k, v := range m.Timestamp {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableDuration) > 0 {
		for k, v := range m.NullableDuration {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.Duration) > 0 {
		for k, v := range m.Duration {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *MapStdTypes) Size() (n int) {
	var l int
	_ = l
	if len(m.NullableTimestamp) > 0 {
		for k, v := range m.NullableTimestamp {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = types1.SizeOfStdTime(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.Timestamp) > 0 {
		for k, v := range m.Timestamp {
			_ = k
			_ = v
			l = types1.SizeOfStdTime(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableDuration) > 0 {
		for k, v := range m.NullableDuration {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = types1.SizeOfStdDuration(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.Duration) > 0 {
		for k, v := range m.Duration {
			_ = k
			_ = v
			l = types1.SizeOfStdDuration(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *OneofProtoTypes) Size() (n int) {
	var l int
	_ = l
	if m.OneOfProtoTimes != nil {
		n += m.OneOfProtoTimes.Size()
	}
	return n
}

func (m *OneofProtoTypes_Timestamp) Size() (n int) {
	var l int
	_ = l
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_Duration) Size() (n int) {
	var l int
	_ = l
	if m.Duration != nil {
		l = m.Duration.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes) Size() (n int) {
	var l int
	_ = l
	if m.OneOfStdTimes != nil {
		n += m.OneOfStdTimes.Size()
	}
	return n
}

func (m *OneofStdTypes_Timestamp) Size() (n int) {
	var l int
	_ = l
	if m.Timestamp != nil {
		l = types1.SizeOfStdTime(*m.Timestamp)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_Duration) Size() (n int) {
	var l int
	_ = l
	if m.Duration != nil {
		l = types1.SizeOfStdDuration(*m.Duration)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func sovTypes(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}

func init() { proto.RegisterFile("combos/marshaler/types.proto", fileDescriptorTypes) }

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