diff --git a/vendor/github.com/golang/protobuf/jsonpb/decode.go b/vendor/github.com/golang/protobuf/jsonpb/decode.go
deleted file mode 100644
index 7c6c5a5..0000000
--- a/vendor/github.com/golang/protobuf/jsonpb/decode.go
+++ /dev/null
@@ -1,514 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package jsonpb
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/golang/protobuf/proto"
-	"google.golang.org/protobuf/encoding/protojson"
-	protoV2 "google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-const wrapJSONUnmarshalV2 = false
-
-// UnmarshalNext unmarshals the next JSON object from d into m.
-func UnmarshalNext(d *json.Decoder, m proto.Message) error {
-	return new(Unmarshaler).UnmarshalNext(d, m)
-}
-
-// Unmarshal unmarshals a JSON object from r into m.
-func Unmarshal(r io.Reader, m proto.Message) error {
-	return new(Unmarshaler).Unmarshal(r, m)
-}
-
-// UnmarshalString unmarshals a JSON object from s into m.
-func UnmarshalString(s string, m proto.Message) error {
-	return new(Unmarshaler).Unmarshal(strings.NewReader(s), m)
-}
-
-// Unmarshaler is a configurable object for converting from a JSON
-// representation to a protocol buffer object.
-type Unmarshaler struct {
-	// AllowUnknownFields specifies whether to allow messages to contain
-	// unknown JSON fields, as opposed to failing to unmarshal.
-	AllowUnknownFields bool
-
-	// AnyResolver is used to resolve the google.protobuf.Any well-known type.
-	// If unset, the global registry is used by default.
-	AnyResolver AnyResolver
-}
-
-// JSONPBUnmarshaler is implemented by protobuf messages that customize the way
-// they are unmarshaled from JSON. Messages that implement this should also
-// implement JSONPBMarshaler so that the custom format can be produced.
-//
-// The JSON unmarshaling must follow the JSON to proto specification:
-//	https://developers.google.com/protocol-buffers/docs/proto3#json
-//
-// Deprecated: Custom types should implement protobuf reflection instead.
-type JSONPBUnmarshaler interface {
-	UnmarshalJSONPB(*Unmarshaler, []byte) error
-}
-
-// Unmarshal unmarshals a JSON object from r into m.
-func (u *Unmarshaler) Unmarshal(r io.Reader, m proto.Message) error {
-	return u.UnmarshalNext(json.NewDecoder(r), m)
-}
-
-// UnmarshalNext unmarshals the next JSON object from d into m.
-func (u *Unmarshaler) UnmarshalNext(d *json.Decoder, m proto.Message) error {
-	if m == nil {
-		return errors.New("invalid nil message")
-	}
-
-	// Parse the next JSON object from the stream.
-	raw := json.RawMessage{}
-	if err := d.Decode(&raw); err != nil {
-		return err
-	}
-
-	// Check for custom unmarshalers first since they may not properly
-	// implement protobuf reflection that the logic below relies on.
-	if jsu, ok := m.(JSONPBUnmarshaler); ok {
-		return jsu.UnmarshalJSONPB(u, raw)
-	}
-
-	mr := proto.MessageReflect(m)
-
-	// NOTE: For historical reasons, a top-level null is treated as a noop.
-	// This is incorrect, but kept for compatibility.
-	if string(raw) == "null" && mr.Descriptor().FullName() != "google.protobuf.Value" {
-		return nil
-	}
-
-	if wrapJSONUnmarshalV2 {
-		// NOTE: If input message is non-empty, we need to preserve merge semantics
-		// of the old jsonpb implementation. These semantics are not supported by
-		// the protobuf JSON specification.
-		isEmpty := true
-		mr.Range(func(protoreflect.FieldDescriptor, protoreflect.Value) bool {
-			isEmpty = false // at least one iteration implies non-empty
-			return false
-		})
-		if !isEmpty {
-			// Perform unmarshaling into a newly allocated, empty message.
-			mr = mr.New()
-
-			// Use a defer to copy all unmarshaled fields into the original message.
-			dst := proto.MessageReflect(m)
-			defer mr.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-				dst.Set(fd, v)
-				return true
-			})
-		}
-
-		// Unmarshal using the v2 JSON unmarshaler.
-		opts := protojson.UnmarshalOptions{
-			DiscardUnknown: u.AllowUnknownFields,
-		}
-		if u.AnyResolver != nil {
-			opts.Resolver = anyResolver{u.AnyResolver}
-		}
-		return opts.Unmarshal(raw, mr.Interface())
-	} else {
-		if err := u.unmarshalMessage(mr, raw); err != nil {
-			return err
-		}
-		return protoV2.CheckInitialized(mr.Interface())
-	}
-}
-
-func (u *Unmarshaler) unmarshalMessage(m protoreflect.Message, in []byte) error {
-	md := m.Descriptor()
-	fds := md.Fields()
-
-	if string(in) == "null" && md.FullName() != "google.protobuf.Value" {
-		return nil
-	}
-
-	if jsu, ok := proto.MessageV1(m.Interface()).(JSONPBUnmarshaler); ok {
-		return jsu.UnmarshalJSONPB(u, in)
-	}
-
-	switch wellKnownType(md.FullName()) {
-	case "Any":
-		var jsonObject map[string]json.RawMessage
-		if err := json.Unmarshal(in, &jsonObject); err != nil {
-			return err
-		}
-
-		rawTypeURL, ok := jsonObject["@type"]
-		if !ok {
-			return errors.New("Any JSON doesn't have '@type'")
-		}
-		typeURL, err := unquoteString(string(rawTypeURL))
-		if err != nil {
-			return fmt.Errorf("can't unmarshal Any's '@type': %q", rawTypeURL)
-		}
-		m.Set(fds.ByNumber(1), protoreflect.ValueOfString(typeURL))
-
-		var m2 protoreflect.Message
-		if u.AnyResolver != nil {
-			mi, err := u.AnyResolver.Resolve(typeURL)
-			if err != nil {
-				return err
-			}
-			m2 = proto.MessageReflect(mi)
-		} else {
-			mt, err := protoregistry.GlobalTypes.FindMessageByURL(typeURL)
-			if err != nil {
-				if err == protoregistry.NotFound {
-					return fmt.Errorf("could not resolve Any message type: %v", typeURL)
-				}
-				return err
-			}
-			m2 = mt.New()
-		}
-
-		if wellKnownType(m2.Descriptor().FullName()) != "" {
-			rawValue, ok := jsonObject["value"]
-			if !ok {
-				return errors.New("Any JSON doesn't have 'value'")
-			}
-			if err := u.unmarshalMessage(m2, rawValue); err != nil {
-				return fmt.Errorf("can't unmarshal Any nested proto %v: %v", typeURL, err)
-			}
-		} else {
-			delete(jsonObject, "@type")
-			rawJSON, err := json.Marshal(jsonObject)
-			if err != nil {
-				return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", err)
-			}
-			if err = u.unmarshalMessage(m2, rawJSON); err != nil {
-				return fmt.Errorf("can't unmarshal Any nested proto %v: %v", typeURL, err)
-			}
-		}
-
-		rawWire, err := protoV2.Marshal(m2.Interface())
-		if err != nil {
-			return fmt.Errorf("can't marshal proto %v into Any.Value: %v", typeURL, err)
-		}
-		m.Set(fds.ByNumber(2), protoreflect.ValueOfBytes(rawWire))
-		return nil
-	case "BoolValue", "BytesValue", "StringValue",
-		"Int32Value", "UInt32Value", "FloatValue",
-		"Int64Value", "UInt64Value", "DoubleValue":
-		fd := fds.ByNumber(1)
-		v, err := u.unmarshalValue(m.NewField(fd), in, fd)
-		if err != nil {
-			return err
-		}
-		m.Set(fd, v)
-		return nil
-	case "Duration":
-		v, err := unquoteString(string(in))
-		if err != nil {
-			return err
-		}
-		d, err := time.ParseDuration(v)
-		if err != nil {
-			return fmt.Errorf("bad Duration: %v", err)
-		}
-
-		sec := d.Nanoseconds() / 1e9
-		nsec := d.Nanoseconds() % 1e9
-		m.Set(fds.ByNumber(1), protoreflect.ValueOfInt64(int64(sec)))
-		m.Set(fds.ByNumber(2), protoreflect.ValueOfInt32(int32(nsec)))
-		return nil
-	case "Timestamp":
-		v, err := unquoteString(string(in))
-		if err != nil {
-			return err
-		}
-		t, err := time.Parse(time.RFC3339Nano, v)
-		if err != nil {
-			return fmt.Errorf("bad Timestamp: %v", err)
-		}
-
-		sec := t.Unix()
-		nsec := t.Nanosecond()
-		m.Set(fds.ByNumber(1), protoreflect.ValueOfInt64(int64(sec)))
-		m.Set(fds.ByNumber(2), protoreflect.ValueOfInt32(int32(nsec)))
-		return nil
-	case "Value":
-		switch {
-		case string(in) == "null":
-			m.Set(fds.ByNumber(1), protoreflect.ValueOfEnum(0))
-		case string(in) == "true":
-			m.Set(fds.ByNumber(4), protoreflect.ValueOfBool(true))
-		case string(in) == "false":
-			m.Set(fds.ByNumber(4), protoreflect.ValueOfBool(false))
-		case hasPrefixAndSuffix('"', in, '"'):
-			s, err := unquoteString(string(in))
-			if err != nil {
-				return fmt.Errorf("unrecognized type for Value %q", in)
-			}
-			m.Set(fds.ByNumber(3), protoreflect.ValueOfString(s))
-		case hasPrefixAndSuffix('[', in, ']'):
-			v := m.Mutable(fds.ByNumber(6))
-			return u.unmarshalMessage(v.Message(), in)
-		case hasPrefixAndSuffix('{', in, '}'):
-			v := m.Mutable(fds.ByNumber(5))
-			return u.unmarshalMessage(v.Message(), in)
-		default:
-			f, err := strconv.ParseFloat(string(in), 0)
-			if err != nil {
-				return fmt.Errorf("unrecognized type for Value %q", in)
-			}
-			m.Set(fds.ByNumber(2), protoreflect.ValueOfFloat64(f))
-		}
-		return nil
-	case "ListValue":
-		var jsonArray []json.RawMessage
-		if err := json.Unmarshal(in, &jsonArray); err != nil {
-			return fmt.Errorf("bad ListValue: %v", err)
-		}
-
-		lv := m.Mutable(fds.ByNumber(1)).List()
-		for _, raw := range jsonArray {
-			ve := lv.NewElement()
-			if err := u.unmarshalMessage(ve.Message(), raw); err != nil {
-				return err
-			}
-			lv.Append(ve)
-		}
-		return nil
-	case "Struct":
-		var jsonObject map[string]json.RawMessage
-		if err := json.Unmarshal(in, &jsonObject); err != nil {
-			return fmt.Errorf("bad StructValue: %v", err)
-		}
-
-		mv := m.Mutable(fds.ByNumber(1)).Map()
-		for key, raw := range jsonObject {
-			kv := protoreflect.ValueOf(key).MapKey()
-			vv := mv.NewValue()
-			if err := u.unmarshalMessage(vv.Message(), raw); err != nil {
-				return fmt.Errorf("bad value in StructValue for key %q: %v", key, err)
-			}
-			mv.Set(kv, vv)
-		}
-		return nil
-	}
-
-	var jsonObject map[string]json.RawMessage
-	if err := json.Unmarshal(in, &jsonObject); err != nil {
-		return err
-	}
-
-	// Handle known fields.
-	for i := 0; i < fds.Len(); i++ {
-		fd := fds.Get(i)
-		if fd.IsWeak() && fd.Message().IsPlaceholder() {
-			continue //  weak reference is not linked in
-		}
-
-		// Search for any raw JSON value associated with this field.
-		var raw json.RawMessage
-		name := string(fd.Name())
-		if fd.Kind() == protoreflect.GroupKind {
-			name = string(fd.Message().Name())
-		}
-		if v, ok := jsonObject[name]; ok {
-			delete(jsonObject, name)
-			raw = v
-		}
-		name = string(fd.JSONName())
-		if v, ok := jsonObject[name]; ok {
-			delete(jsonObject, name)
-			raw = v
-		}
-
-		// Unmarshal the field value.
-		if raw == nil || (string(raw) == "null" && !isSingularWellKnownValue(fd)) {
-			continue
-		}
-		v, err := u.unmarshalValue(m.NewField(fd), raw, fd)
-		if err != nil {
-			return err
-		}
-		m.Set(fd, v)
-	}
-
-	// Handle extension fields.
-	for name, raw := range jsonObject {
-		if !strings.HasPrefix(name, "[") || !strings.HasSuffix(name, "]") {
-			continue
-		}
-
-		// Resolve the extension field by name.
-		xname := protoreflect.FullName(name[len("[") : len(name)-len("]")])
-		xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname)
-		if xt == nil && isMessageSet(md) {
-			xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension"))
-		}
-		if xt == nil {
-			continue
-		}
-		delete(jsonObject, name)
-		fd := xt.TypeDescriptor()
-		if fd.ContainingMessage().FullName() != m.Descriptor().FullName() {
-			return fmt.Errorf("extension field %q does not extend message %q", xname, m.Descriptor().FullName())
-		}
-
-		// Unmarshal the field value.
-		if raw == nil || (string(raw) == "null" && !isSingularWellKnownValue(fd)) {
-			continue
-		}
-		v, err := u.unmarshalValue(m.NewField(fd), raw, fd)
-		if err != nil {
-			return err
-		}
-		m.Set(fd, v)
-	}
-
-	if !u.AllowUnknownFields && len(jsonObject) > 0 {
-		for name := range jsonObject {
-			return fmt.Errorf("unknown field %q in %v", name, md.FullName())
-		}
-	}
-	return nil
-}
-
-func isSingularWellKnownValue(fd protoreflect.FieldDescriptor) bool {
-	if md := fd.Message(); md != nil {
-		return md.FullName() == "google.protobuf.Value" && fd.Cardinality() != protoreflect.Repeated
-	}
-	return false
-}
-
-func (u *Unmarshaler) unmarshalValue(v protoreflect.Value, in []byte, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
-	switch {
-	case fd.IsList():
-		var jsonArray []json.RawMessage
-		if err := json.Unmarshal(in, &jsonArray); err != nil {
-			return v, err
-		}
-		lv := v.List()
-		for _, raw := range jsonArray {
-			ve, err := u.unmarshalSingularValue(lv.NewElement(), raw, fd)
-			if err != nil {
-				return v, err
-			}
-			lv.Append(ve)
-		}
-		return v, nil
-	case fd.IsMap():
-		var jsonObject map[string]json.RawMessage
-		if err := json.Unmarshal(in, &jsonObject); err != nil {
-			return v, err
-		}
-		kfd := fd.MapKey()
-		vfd := fd.MapValue()
-		mv := v.Map()
-		for key, raw := range jsonObject {
-			var kv protoreflect.MapKey
-			if kfd.Kind() == protoreflect.StringKind {
-				kv = protoreflect.ValueOf(key).MapKey()
-			} else {
-				v, err := u.unmarshalSingularValue(kfd.Default(), []byte(key), kfd)
-				if err != nil {
-					return v, err
-				}
-				kv = v.MapKey()
-			}
-
-			vv, err := u.unmarshalSingularValue(mv.NewValue(), raw, vfd)
-			if err != nil {
-				return v, err
-			}
-			mv.Set(kv, vv)
-		}
-		return v, nil
-	default:
-		return u.unmarshalSingularValue(v, in, fd)
-	}
-}
-
-var nonFinite = map[string]float64{
-	`"NaN"`:       math.NaN(),
-	`"Infinity"`:  math.Inf(+1),
-	`"-Infinity"`: math.Inf(-1),
-}
-
-func (u *Unmarshaler) unmarshalSingularValue(v protoreflect.Value, in []byte, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
-	switch fd.Kind() {
-	case protoreflect.BoolKind:
-		return unmarshalValue(in, new(bool))
-	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
-		return unmarshalValue(trimQuote(in), new(int32))
-	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
-		return unmarshalValue(trimQuote(in), new(int64))
-	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
-		return unmarshalValue(trimQuote(in), new(uint32))
-	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
-		return unmarshalValue(trimQuote(in), new(uint64))
-	case protoreflect.FloatKind:
-		if f, ok := nonFinite[string(in)]; ok {
-			return protoreflect.ValueOfFloat32(float32(f)), nil
-		}
-		return unmarshalValue(trimQuote(in), new(float32))
-	case protoreflect.DoubleKind:
-		if f, ok := nonFinite[string(in)]; ok {
-			return protoreflect.ValueOfFloat64(float64(f)), nil
-		}
-		return unmarshalValue(trimQuote(in), new(float64))
-	case protoreflect.StringKind:
-		return unmarshalValue(in, new(string))
-	case protoreflect.BytesKind:
-		return unmarshalValue(in, new([]byte))
-	case protoreflect.EnumKind:
-		if hasPrefixAndSuffix('"', in, '"') {
-			vd := fd.Enum().Values().ByName(protoreflect.Name(trimQuote(in)))
-			if vd == nil {
-				return v, fmt.Errorf("unknown value %q for enum %s", in, fd.Enum().FullName())
-			}
-			return protoreflect.ValueOfEnum(vd.Number()), nil
-		}
-		return unmarshalValue(in, new(protoreflect.EnumNumber))
-	case protoreflect.MessageKind, protoreflect.GroupKind:
-		err := u.unmarshalMessage(v.Message(), in)
-		return v, err
-	default:
-		panic(fmt.Sprintf("invalid kind %v", fd.Kind()))
-	}
-}
-
-func unmarshalValue(in []byte, v interface{}) (protoreflect.Value, error) {
-	err := json.Unmarshal(in, v)
-	return protoreflect.ValueOf(reflect.ValueOf(v).Elem().Interface()), err
-}
-
-func unquoteString(in string) (out string, err error) {
-	err = json.Unmarshal([]byte(in), &out)
-	return out, err
-}
-
-func hasPrefixAndSuffix(prefix byte, in []byte, suffix byte) bool {
-	if len(in) >= 2 && in[0] == prefix && in[len(in)-1] == suffix {
-		return true
-	}
-	return false
-}
-
-// trimQuote is like unquoteString but simply strips surrounding quotes.
-// This is incorrect, but is behavior done by the legacy implementation.
-func trimQuote(in []byte) []byte {
-	if len(in) >= 2 && in[0] == '"' && in[len(in)-1] == '"' {
-		in = in[1 : len(in)-1]
-	}
-	return in
-}
diff --git a/vendor/github.com/golang/protobuf/jsonpb/encode.go b/vendor/github.com/golang/protobuf/jsonpb/encode.go
deleted file mode 100644
index 7633019..0000000
--- a/vendor/github.com/golang/protobuf/jsonpb/encode.go
+++ /dev/null
@@ -1,554 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package jsonpb
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/golang/protobuf/proto"
-	"google.golang.org/protobuf/encoding/protojson"
-	protoV2 "google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-const wrapJSONMarshalV2 = false
-
-// Marshaler is a configurable object for marshaling protocol buffer messages
-// to the specified JSON representation.
-type Marshaler struct {
-	// OrigName specifies whether to use the original protobuf name for fields.
-	OrigName bool
-
-	// EnumsAsInts specifies whether to render enum values as integers,
-	// as opposed to string values.
-	EnumsAsInts bool
-
-	// EmitDefaults specifies whether to render fields with zero values.
-	EmitDefaults bool
-
-	// Indent controls whether the output is compact or not.
-	// If empty, the output is compact JSON. Otherwise, every JSON object
-	// entry and JSON array value will be on its own line.
-	// Each line will be preceded by repeated copies of Indent, where the
-	// number of copies is the current indentation depth.
-	Indent string
-
-	// AnyResolver is used to resolve the google.protobuf.Any well-known type.
-	// If unset, the global registry is used by default.
-	AnyResolver AnyResolver
-}
-
-// JSONPBMarshaler is implemented by protobuf messages that customize the
-// way they are marshaled to JSON. Messages that implement this should also
-// implement JSONPBUnmarshaler so that the custom format can be parsed.
-//
-// The JSON marshaling must follow the proto to JSON specification:
-//	https://developers.google.com/protocol-buffers/docs/proto3#json
-//
-// Deprecated: Custom types should implement protobuf reflection instead.
-type JSONPBMarshaler interface {
-	MarshalJSONPB(*Marshaler) ([]byte, error)
-}
-
-// Marshal serializes a protobuf message as JSON into w.
-func (jm *Marshaler) Marshal(w io.Writer, m proto.Message) error {
-	b, err := jm.marshal(m)
-	if len(b) > 0 {
-		if _, err := w.Write(b); err != nil {
-			return err
-		}
-	}
-	return err
-}
-
-// MarshalToString serializes a protobuf message as JSON in string form.
-func (jm *Marshaler) MarshalToString(m proto.Message) (string, error) {
-	b, err := jm.marshal(m)
-	if err != nil {
-		return "", err
-	}
-	return string(b), nil
-}
-
-func (jm *Marshaler) marshal(m proto.Message) ([]byte, error) {
-	v := reflect.ValueOf(m)
-	if m == nil || (v.Kind() == reflect.Ptr && v.IsNil()) {
-		return nil, errors.New("Marshal called with nil")
-	}
-
-	// Check for custom marshalers first since they may not properly
-	// implement protobuf reflection that the logic below relies on.
-	if jsm, ok := m.(JSONPBMarshaler); ok {
-		return jsm.MarshalJSONPB(jm)
-	}
-
-	if wrapJSONMarshalV2 {
-		opts := protojson.MarshalOptions{
-			UseProtoNames:   jm.OrigName,
-			UseEnumNumbers:  jm.EnumsAsInts,
-			EmitUnpopulated: jm.EmitDefaults,
-			Indent:          jm.Indent,
-		}
-		if jm.AnyResolver != nil {
-			opts.Resolver = anyResolver{jm.AnyResolver}
-		}
-		return opts.Marshal(proto.MessageReflect(m).Interface())
-	} else {
-		// Check for unpopulated required fields first.
-		m2 := proto.MessageReflect(m)
-		if err := protoV2.CheckInitialized(m2.Interface()); err != nil {
-			return nil, err
-		}
-
-		w := jsonWriter{Marshaler: jm}
-		err := w.marshalMessage(m2, "", "")
-		return w.buf, err
-	}
-}
-
-type jsonWriter struct {
-	*Marshaler
-	buf []byte
-}
-
-func (w *jsonWriter) write(s string) {
-	w.buf = append(w.buf, s...)
-}
-
-func (w *jsonWriter) marshalMessage(m protoreflect.Message, indent, typeURL string) error {
-	if jsm, ok := proto.MessageV1(m.Interface()).(JSONPBMarshaler); ok {
-		b, err := jsm.MarshalJSONPB(w.Marshaler)
-		if err != nil {
-			return err
-		}
-		if typeURL != "" {
-			// we are marshaling this object to an Any type
-			var js map[string]*json.RawMessage
-			if err = json.Unmarshal(b, &js); err != nil {
-				return fmt.Errorf("type %T produced invalid JSON: %v", m.Interface(), err)
-			}
-			turl, err := json.Marshal(typeURL)
-			if err != nil {
-				return fmt.Errorf("failed to marshal type URL %q to JSON: %v", typeURL, err)
-			}
-			js["@type"] = (*json.RawMessage)(&turl)
-			if b, err = json.Marshal(js); err != nil {
-				return err
-			}
-		}
-		w.write(string(b))
-		return nil
-	}
-
-	md := m.Descriptor()
-	fds := md.Fields()
-
-	// Handle well-known types.
-	const secondInNanos = int64(time.Second / time.Nanosecond)
-	switch wellKnownType(md.FullName()) {
-	case "Any":
-		return w.marshalAny(m, indent)
-	case "BoolValue", "BytesValue", "StringValue",
-		"Int32Value", "UInt32Value", "FloatValue",
-		"Int64Value", "UInt64Value", "DoubleValue":
-		fd := fds.ByNumber(1)
-		return w.marshalValue(fd, m.Get(fd), indent)
-	case "Duration":
-		// "Generated output always contains 0, 3, 6, or 9 fractional digits,
-		//  depending on required precision."
-		s := m.Get(fds.ByNumber(1)).Int()
-		ns := m.Get(fds.ByNumber(2)).Int()
-		if ns <= -secondInNanos || ns >= secondInNanos {
-			return fmt.Errorf("ns out of range (%v, %v)", -secondInNanos, secondInNanos)
-		}
-		if (s > 0 && ns < 0) || (s < 0 && ns > 0) {
-			return errors.New("signs of seconds and nanos do not match")
-		}
-		if s < 0 {
-			ns = -ns
-		}
-		x := fmt.Sprintf("%d.%09d", s, ns)
-		x = strings.TrimSuffix(x, "000")
-		x = strings.TrimSuffix(x, "000")
-		x = strings.TrimSuffix(x, ".000")
-		w.write(fmt.Sprintf(`"%vs"`, x))
-		return nil
-	case "Timestamp":
-		// "RFC 3339, where generated output will always be Z-normalized
-		//  and uses 0, 3, 6 or 9 fractional digits."
-		s := m.Get(fds.ByNumber(1)).Int()
-		ns := m.Get(fds.ByNumber(2)).Int()
-		if ns < 0 || ns >= secondInNanos {
-			return fmt.Errorf("ns out of range [0, %v)", secondInNanos)
-		}
-		t := time.Unix(s, ns).UTC()
-		// time.RFC3339Nano isn't exactly right (we need to get 3/6/9 fractional digits).
-		x := t.Format("2006-01-02T15:04:05.000000000")
-		x = strings.TrimSuffix(x, "000")
-		x = strings.TrimSuffix(x, "000")
-		x = strings.TrimSuffix(x, ".000")
-		w.write(fmt.Sprintf(`"%vZ"`, x))
-		return nil
-	case "Value":
-		// JSON value; which is a null, number, string, bool, object, or array.
-		od := md.Oneofs().Get(0)
-		fd := m.WhichOneof(od)
-		if fd == nil {
-			return errors.New("nil Value")
-		}
-		return w.marshalValue(fd, m.Get(fd), indent)
-	case "Struct", "ListValue":
-		// JSON object or array.
-		fd := fds.ByNumber(1)
-		return w.marshalValue(fd, m.Get(fd), indent)
-	}
-
-	w.write("{")
-	if w.Indent != "" {
-		w.write("\n")
-	}
-
-	firstField := true
-	if typeURL != "" {
-		if err := w.marshalTypeURL(indent, typeURL); err != nil {
-			return err
-		}
-		firstField = false
-	}
-
-	for i := 0; i < fds.Len(); {
-		fd := fds.Get(i)
-		if od := fd.ContainingOneof(); od != nil {
-			fd = m.WhichOneof(od)
-			i += od.Fields().Len()
-			if fd == nil {
-				continue
-			}
-		} else {
-			i++
-		}
-
-		v := m.Get(fd)
-
-		if !m.Has(fd) {
-			if !w.EmitDefaults || fd.ContainingOneof() != nil {
-				continue
-			}
-			if fd.Cardinality() != protoreflect.Repeated && (fd.Message() != nil || fd.Syntax() == protoreflect.Proto2) {
-				v = protoreflect.Value{} // use "null" for singular messages or proto2 scalars
-			}
-		}
-
-		if !firstField {
-			w.writeComma()
-		}
-		if err := w.marshalField(fd, v, indent); err != nil {
-			return err
-		}
-		firstField = false
-	}
-
-	// Handle proto2 extensions.
-	if md.ExtensionRanges().Len() > 0 {
-		// Collect a sorted list of all extension descriptor and values.
-		type ext struct {
-			desc protoreflect.FieldDescriptor
-			val  protoreflect.Value
-		}
-		var exts []ext
-		m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-			if fd.IsExtension() {
-				exts = append(exts, ext{fd, v})
-			}
-			return true
-		})
-		sort.Slice(exts, func(i, j int) bool {
-			return exts[i].desc.Number() < exts[j].desc.Number()
-		})
-
-		for _, ext := range exts {
-			if !firstField {
-				w.writeComma()
-			}
-			if err := w.marshalField(ext.desc, ext.val, indent); err != nil {
-				return err
-			}
-			firstField = false
-		}
-	}
-
-	if w.Indent != "" {
-		w.write("\n")
-		w.write(indent)
-	}
-	w.write("}")
-	return nil
-}
-
-func (w *jsonWriter) writeComma() {
-	if w.Indent != "" {
-		w.write(",\n")
-	} else {
-		w.write(",")
-	}
-}
-
-func (w *jsonWriter) marshalAny(m protoreflect.Message, indent string) error {
-	// "If the Any contains a value that has a special JSON mapping,
-	//  it will be converted as follows: {"@type": xxx, "value": yyy}.
-	//  Otherwise, the value will be converted into a JSON object,
-	//  and the "@type" field will be inserted to indicate the actual data type."
-	md := m.Descriptor()
-	typeURL := m.Get(md.Fields().ByNumber(1)).String()
-	rawVal := m.Get(md.Fields().ByNumber(2)).Bytes()
-
-	var m2 protoreflect.Message
-	if w.AnyResolver != nil {
-		mi, err := w.AnyResolver.Resolve(typeURL)
-		if err != nil {
-			return err
-		}
-		m2 = proto.MessageReflect(mi)
-	} else {
-		mt, err := protoregistry.GlobalTypes.FindMessageByURL(typeURL)
-		if err != nil {
-			return err
-		}
-		m2 = mt.New()
-	}
-
-	if err := protoV2.Unmarshal(rawVal, m2.Interface()); err != nil {
-		return err
-	}
-
-	if wellKnownType(m2.Descriptor().FullName()) == "" {
-		return w.marshalMessage(m2, indent, typeURL)
-	}
-
-	w.write("{")
-	if w.Indent != "" {
-		w.write("\n")
-	}
-	if err := w.marshalTypeURL(indent, typeURL); err != nil {
-		return err
-	}
-	w.writeComma()
-	if w.Indent != "" {
-		w.write(indent)
-		w.write(w.Indent)
-		w.write(`"value": `)
-	} else {
-		w.write(`"value":`)
-	}
-	if err := w.marshalMessage(m2, indent+w.Indent, ""); err != nil {
-		return err
-	}
-	if w.Indent != "" {
-		w.write("\n")
-		w.write(indent)
-	}
-	w.write("}")
-	return nil
-}
-
-func (w *jsonWriter) marshalTypeURL(indent, typeURL string) error {
-	if w.Indent != "" {
-		w.write(indent)
-		w.write(w.Indent)
-	}
-	w.write(`"@type":`)
-	if w.Indent != "" {
-		w.write(" ")
-	}
-	b, err := json.Marshal(typeURL)
-	if err != nil {
-		return err
-	}
-	w.write(string(b))
-	return nil
-}
-
-// marshalField writes field description and value to the Writer.
-func (w *jsonWriter) marshalField(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error {
-	if w.Indent != "" {
-		w.write(indent)
-		w.write(w.Indent)
-	}
-	w.write(`"`)
-	switch {
-	case fd.IsExtension():
-		// For message set, use the fname of the message as the extension name.
-		name := string(fd.FullName())
-		if isMessageSet(fd.ContainingMessage()) {
-			name = strings.TrimSuffix(name, ".message_set_extension")
-		}
-
-		w.write("[" + name + "]")
-	case w.OrigName:
-		name := string(fd.Name())
-		if fd.Kind() == protoreflect.GroupKind {
-			name = string(fd.Message().Name())
-		}
-		w.write(name)
-	default:
-		w.write(string(fd.JSONName()))
-	}
-	w.write(`":`)
-	if w.Indent != "" {
-		w.write(" ")
-	}
-	return w.marshalValue(fd, v, indent)
-}
-
-func (w *jsonWriter) marshalValue(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error {
-	switch {
-	case fd.IsList():
-		w.write("[")
-		comma := ""
-		lv := v.List()
-		for i := 0; i < lv.Len(); i++ {
-			w.write(comma)
-			if w.Indent != "" {
-				w.write("\n")
-				w.write(indent)
-				w.write(w.Indent)
-				w.write(w.Indent)
-			}
-			if err := w.marshalSingularValue(fd, lv.Get(i), indent+w.Indent); err != nil {
-				return err
-			}
-			comma = ","
-		}
-		if w.Indent != "" {
-			w.write("\n")
-			w.write(indent)
-			w.write(w.Indent)
-		}
-		w.write("]")
-		return nil
-	case fd.IsMap():
-		kfd := fd.MapKey()
-		vfd := fd.MapValue()
-		mv := v.Map()
-
-		// Collect a sorted list of all map keys and values.
-		type entry struct{ key, val protoreflect.Value }
-		var entries []entry
-		mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
-			entries = append(entries, entry{k.Value(), v})
-			return true
-		})
-		sort.Slice(entries, func(i, j int) bool {
-			switch kfd.Kind() {
-			case protoreflect.BoolKind:
-				return !entries[i].key.Bool() && entries[j].key.Bool()
-			case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
-				return entries[i].key.Int() < entries[j].key.Int()
-			case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
-				return entries[i].key.Uint() < entries[j].key.Uint()
-			case protoreflect.StringKind:
-				return entries[i].key.String() < entries[j].key.String()
-			default:
-				panic("invalid kind")
-			}
-		})
-
-		w.write(`{`)
-		comma := ""
-		for _, entry := range entries {
-			w.write(comma)
-			if w.Indent != "" {
-				w.write("\n")
-				w.write(indent)
-				w.write(w.Indent)
-				w.write(w.Indent)
-			}
-
-			s := fmt.Sprint(entry.key.Interface())
-			b, err := json.Marshal(s)
-			if err != nil {
-				return err
-			}
-			w.write(string(b))
-
-			w.write(`:`)
-			if w.Indent != "" {
-				w.write(` `)
-			}
-
-			if err := w.marshalSingularValue(vfd, entry.val, indent+w.Indent); err != nil {
-				return err
-			}
-			comma = ","
-		}
-		if w.Indent != "" {
-			w.write("\n")
-			w.write(indent)
-			w.write(w.Indent)
-		}
-		w.write(`}`)
-		return nil
-	default:
-		return w.marshalSingularValue(fd, v, indent)
-	}
-}
-
-func (w *jsonWriter) marshalSingularValue(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error {
-	switch {
-	case !v.IsValid():
-		w.write("null")
-		return nil
-	case fd.Message() != nil:
-		return w.marshalMessage(v.Message(), indent+w.Indent, "")
-	case fd.Enum() != nil:
-		if fd.Enum().FullName() == "google.protobuf.NullValue" {
-			w.write("null")
-			return nil
-		}
-
-		vd := fd.Enum().Values().ByNumber(v.Enum())
-		if vd == nil || w.EnumsAsInts {
-			w.write(strconv.Itoa(int(v.Enum())))
-		} else {
-			w.write(`"` + string(vd.Name()) + `"`)
-		}
-		return nil
-	default:
-		switch v.Interface().(type) {
-		case float32, float64:
-			switch {
-			case math.IsInf(v.Float(), +1):
-				w.write(`"Infinity"`)
-				return nil
-			case math.IsInf(v.Float(), -1):
-				w.write(`"-Infinity"`)
-				return nil
-			case math.IsNaN(v.Float()):
-				w.write(`"NaN"`)
-				return nil
-			}
-		case int64, uint64:
-			w.write(fmt.Sprintf(`"%d"`, v.Interface()))
-			return nil
-		}
-
-		b, err := json.Marshal(v.Interface())
-		if err != nil {
-			return err
-		}
-		w.write(string(b))
-		return nil
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/jsonpb/json.go b/vendor/github.com/golang/protobuf/jsonpb/json.go
deleted file mode 100644
index 480e244..0000000
--- a/vendor/github.com/golang/protobuf/jsonpb/json.go
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package jsonpb provides functionality to marshal and unmarshal between a
-// protocol buffer message and JSON. It follows the specification at
-// https://developers.google.com/protocol-buffers/docs/proto3#json.
-//
-// Do not rely on the default behavior of the standard encoding/json package
-// when called on generated message types as it does not operate correctly.
-//
-// Deprecated: Use the "google.golang.org/protobuf/encoding/protojson"
-// package instead.
-package jsonpb
-
-import (
-	"github.com/golang/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-	"google.golang.org/protobuf/runtime/protoimpl"
-)
-
-// AnyResolver takes a type URL, present in an Any message,
-// and resolves it into an instance of the associated message.
-type AnyResolver interface {
-	Resolve(typeURL string) (proto.Message, error)
-}
-
-type anyResolver struct{ AnyResolver }
-
-func (r anyResolver) FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) {
-	return r.FindMessageByURL(string(message))
-}
-
-func (r anyResolver) FindMessageByURL(url string) (protoreflect.MessageType, error) {
-	m, err := r.Resolve(url)
-	if err != nil {
-		return nil, err
-	}
-	return protoimpl.X.MessageTypeOf(m), nil
-}
-
-func (r anyResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
-	return protoregistry.GlobalTypes.FindExtensionByName(field)
-}
-
-func (r anyResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
-	return protoregistry.GlobalTypes.FindExtensionByNumber(message, field)
-}
-
-func wellKnownType(s protoreflect.FullName) string {
-	if s.Parent() == "google.protobuf" {
-		switch s.Name() {
-		case "Empty", "Any",
-			"BoolValue", "BytesValue", "StringValue",
-			"Int32Value", "UInt32Value", "FloatValue",
-			"Int64Value", "UInt64Value", "DoubleValue",
-			"Duration", "Timestamp",
-			"NullValue", "Struct", "Value", "ListValue":
-			return string(s.Name())
-		}
-	}
-	return ""
-}
-
-func isMessageSet(md protoreflect.MessageDescriptor) bool {
-	ms, ok := md.(interface{ IsMessageSet() bool })
-	return ok && ms.IsMessageSet()
-}
diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go b/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go
new file mode 100644
index 0000000..e9cc202
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go
@@ -0,0 +1,1284 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2015 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/*
+Package jsonpb provides marshaling and unmarshaling between protocol buffers and JSON.
+It follows the specification at https://developers.google.com/protocol-buffers/docs/proto3#json.
+
+This package produces a different output than the standard "encoding/json" package,
+which does not operate correctly on protocol buffers.
+*/
+package jsonpb
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+
+	stpb "github.com/golang/protobuf/ptypes/struct"
+)
+
+const secondInNanos = int64(time.Second / time.Nanosecond)
+const maxSecondsInDuration = 315576000000
+
+// Marshaler is a configurable object for converting between
+// protocol buffer objects and a JSON representation for them.
+type Marshaler struct {
+	// Whether to render enum values as integers, as opposed to string values.
+	EnumsAsInts bool
+
+	// Whether to render fields with zero values.
+	EmitDefaults bool
+
+	// A string to indent each level by. The presence of this field will
+	// also cause a space to appear between the field separator and
+	// value, and for newlines to be appear between fields and array
+	// elements.
+	Indent string
+
+	// Whether to use the original (.proto) name for fields.
+	OrigName bool
+
+	// A custom URL resolver to use when marshaling Any messages to JSON.
+	// If unset, the default resolution strategy is to extract the
+	// fully-qualified type name from the type URL and pass that to
+	// proto.MessageType(string).
+	AnyResolver AnyResolver
+}
+
+// AnyResolver takes a type URL, present in an Any message, and resolves it into
+// an instance of the associated message.
+type AnyResolver interface {
+	Resolve(typeUrl string) (proto.Message, error)
+}
+
+func defaultResolveAny(typeUrl string) (proto.Message, error) {
+	// Only the part of typeUrl after the last slash is relevant.
+	mname := typeUrl
+	if slash := strings.LastIndex(mname, "/"); slash >= 0 {
+		mname = mname[slash+1:]
+	}
+	mt := proto.MessageType(mname)
+	if mt == nil {
+		return nil, fmt.Errorf("unknown message type %q", mname)
+	}
+	return reflect.New(mt.Elem()).Interface().(proto.Message), nil
+}
+
+// JSONPBMarshaler is implemented by protobuf messages that customize the
+// way they are marshaled to JSON. Messages that implement this should
+// also implement JSONPBUnmarshaler so that the custom format can be
+// parsed.
+//
+// The JSON marshaling must follow the proto to JSON specification:
+//	https://developers.google.com/protocol-buffers/docs/proto3#json
+type JSONPBMarshaler interface {
+	MarshalJSONPB(*Marshaler) ([]byte, error)
+}
+
+// JSONPBUnmarshaler is implemented by protobuf messages that customize
+// the way they are unmarshaled from JSON. Messages that implement this
+// should also implement JSONPBMarshaler so that the custom format can be
+// produced.
+//
+// The JSON unmarshaling must follow the JSON to proto specification:
+//	https://developers.google.com/protocol-buffers/docs/proto3#json
+type JSONPBUnmarshaler interface {
+	UnmarshalJSONPB(*Unmarshaler, []byte) error
+}
+
+// Marshal marshals a protocol buffer into JSON.
+func (m *Marshaler) Marshal(out io.Writer, pb proto.Message) error {
+	v := reflect.ValueOf(pb)
+	if pb == nil || (v.Kind() == reflect.Ptr && v.IsNil()) {
+		return errors.New("Marshal called with nil")
+	}
+	// Check for unset required fields first.
+	if err := checkRequiredFields(pb); err != nil {
+		return err
+	}
+	writer := &errWriter{writer: out}
+	return m.marshalObject(writer, pb, "", "")
+}
+
+// MarshalToString converts a protocol buffer object to JSON string.
+func (m *Marshaler) MarshalToString(pb proto.Message) (string, error) {
+	var buf bytes.Buffer
+	if err := m.Marshal(&buf, pb); err != nil {
+		return "", err
+	}
+	return buf.String(), nil
+}
+
+type int32Slice []int32
+
+var nonFinite = map[string]float64{
+	`"NaN"`:       math.NaN(),
+	`"Infinity"`:  math.Inf(1),
+	`"-Infinity"`: math.Inf(-1),
+}
+
+// For sorting extensions ids to ensure stable output.
+func (s int32Slice) Len() int           { return len(s) }
+func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
+func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+type wkt interface {
+	XXX_WellKnownType() string
+}
+
+// marshalObject writes a struct to the Writer.
+func (m *Marshaler) marshalObject(out *errWriter, v proto.Message, indent, typeURL string) error {
+	if jsm, ok := v.(JSONPBMarshaler); ok {
+		b, err := jsm.MarshalJSONPB(m)
+		if err != nil {
+			return err
+		}
+		if typeURL != "" {
+			// we are marshaling this object to an Any type
+			var js map[string]*json.RawMessage
+			if err = json.Unmarshal(b, &js); err != nil {
+				return fmt.Errorf("type %T produced invalid JSON: %v", v, err)
+			}
+			turl, err := json.Marshal(typeURL)
+			if err != nil {
+				return fmt.Errorf("failed to marshal type URL %q to JSON: %v", typeURL, err)
+			}
+			js["@type"] = (*json.RawMessage)(&turl)
+			if m.Indent != "" {
+				b, err = json.MarshalIndent(js, indent, m.Indent)
+			} else {
+				b, err = json.Marshal(js)
+			}
+			if err != nil {
+				return err
+			}
+		}
+
+		out.write(string(b))
+		return out.err
+	}
+
+	s := reflect.ValueOf(v).Elem()
+
+	// Handle well-known types.
+	if wkt, ok := v.(wkt); ok {
+		switch wkt.XXX_WellKnownType() {
+		case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value",
+			"Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue":
+			// "Wrappers use the same representation in JSON
+			//  as the wrapped primitive type, ..."
+			sprop := proto.GetProperties(s.Type())
+			return m.marshalValue(out, sprop.Prop[0], s.Field(0), indent)
+		case "Any":
+			// Any is a bit more involved.
+			return m.marshalAny(out, v, indent)
+		case "Duration":
+			s, ns := s.Field(0).Int(), s.Field(1).Int()
+			if s < -maxSecondsInDuration || s > maxSecondsInDuration {
+				return fmt.Errorf("seconds out of range %v", s)
+			}
+			if ns <= -secondInNanos || ns >= secondInNanos {
+				return fmt.Errorf("ns out of range (%v, %v)", -secondInNanos, secondInNanos)
+			}
+			if (s > 0 && ns < 0) || (s < 0 && ns > 0) {
+				return errors.New("signs of seconds and nanos do not match")
+			}
+			// Generated output always contains 0, 3, 6, or 9 fractional digits,
+			// depending on required precision, followed by the suffix "s".
+			f := "%d.%09d"
+			if ns < 0 {
+				ns = -ns
+				if s == 0 {
+					f = "-%d.%09d"
+				}
+			}
+			x := fmt.Sprintf(f, s, ns)
+			x = strings.TrimSuffix(x, "000")
+			x = strings.TrimSuffix(x, "000")
+			x = strings.TrimSuffix(x, ".000")
+			out.write(`"`)
+			out.write(x)
+			out.write(`s"`)
+			return out.err
+		case "Struct", "ListValue":
+			// Let marshalValue handle the `Struct.fields` map or the `ListValue.values` slice.
+			// TODO: pass the correct Properties if needed.
+			return m.marshalValue(out, &proto.Properties{}, s.Field(0), indent)
+		case "Timestamp":
+			// "RFC 3339, where generated output will always be Z-normalized
+			//  and uses 0, 3, 6 or 9 fractional digits."
+			s, ns := s.Field(0).Int(), s.Field(1).Int()
+			if ns < 0 || ns >= secondInNanos {
+				return fmt.Errorf("ns out of range [0, %v)", secondInNanos)
+			}
+			t := time.Unix(s, ns).UTC()
+			// time.RFC3339Nano isn't exactly right (we need to get 3/6/9 fractional digits).
+			x := t.Format("2006-01-02T15:04:05.000000000")
+			x = strings.TrimSuffix(x, "000")
+			x = strings.TrimSuffix(x, "000")
+			x = strings.TrimSuffix(x, ".000")
+			out.write(`"`)
+			out.write(x)
+			out.write(`Z"`)
+			return out.err
+		case "Value":
+			// Value has a single oneof.
+			kind := s.Field(0)
+			if kind.IsNil() {
+				// "absence of any variant indicates an error"
+				return errors.New("nil Value")
+			}
+			// oneof -> *T -> T -> T.F
+			x := kind.Elem().Elem().Field(0)
+			// TODO: pass the correct Properties if needed.
+			return m.marshalValue(out, &proto.Properties{}, x, indent)
+		}
+	}
+
+	out.write("{")
+	if m.Indent != "" {
+		out.write("\n")
+	}
+
+	firstField := true
+
+	if typeURL != "" {
+		if err := m.marshalTypeURL(out, indent, typeURL); err != nil {
+			return err
+		}
+		firstField = false
+	}
+
+	for i := 0; i < s.NumField(); i++ {
+		value := s.Field(i)
+		valueField := s.Type().Field(i)
+		if strings.HasPrefix(valueField.Name, "XXX_") {
+			continue
+		}
+
+		// IsNil will panic on most value kinds.
+		switch value.Kind() {
+		case reflect.Chan, reflect.Func, reflect.Interface:
+			if value.IsNil() {
+				continue
+			}
+		}
+
+		if !m.EmitDefaults {
+			switch value.Kind() {
+			case reflect.Bool:
+				if !value.Bool() {
+					continue
+				}
+			case reflect.Int32, reflect.Int64:
+				if value.Int() == 0 {
+					continue
+				}
+			case reflect.Uint32, reflect.Uint64:
+				if value.Uint() == 0 {
+					continue
+				}
+			case reflect.Float32, reflect.Float64:
+				if value.Float() == 0 {
+					continue
+				}
+			case reflect.String:
+				if value.Len() == 0 {
+					continue
+				}
+			case reflect.Map, reflect.Ptr, reflect.Slice:
+				if value.IsNil() {
+					continue
+				}
+			}
+		}
+
+		// Oneof fields need special handling.
+		if valueField.Tag.Get("protobuf_oneof") != "" {
+			// value is an interface containing &T{real_value}.
+			sv := value.Elem().Elem() // interface -> *T -> T
+			value = sv.Field(0)
+			valueField = sv.Type().Field(0)
+		}
+		prop := jsonProperties(valueField, m.OrigName)
+		if !firstField {
+			m.writeSep(out)
+		}
+		if err := m.marshalField(out, prop, value, indent); err != nil {
+			return err
+		}
+		firstField = false
+	}
+
+	// Handle proto2 extensions.
+	if ep, ok := v.(proto.Message); ok {
+		extensions := proto.RegisteredExtensions(v)
+		// Sort extensions for stable output.
+		ids := make([]int32, 0, len(extensions))
+		for id, desc := range extensions {
+			if !proto.HasExtension(ep, desc) {
+				continue
+			}
+			ids = append(ids, id)
+		}
+		sort.Sort(int32Slice(ids))
+		for _, id := range ids {
+			desc := extensions[id]
+			if desc == nil {
+				// unknown extension
+				continue
+			}
+			ext, extErr := proto.GetExtension(ep, desc)
+			if extErr != nil {
+				return extErr
+			}
+			value := reflect.ValueOf(ext)
+			var prop proto.Properties
+			prop.Parse(desc.Tag)
+			prop.JSONName = fmt.Sprintf("[%s]", desc.Name)
+			if !firstField {
+				m.writeSep(out)
+			}
+			if err := m.marshalField(out, &prop, value, indent); err != nil {
+				return err
+			}
+			firstField = false
+		}
+
+	}
+
+	if m.Indent != "" {
+		out.write("\n")
+		out.write(indent)
+	}
+	out.write("}")
+	return out.err
+}
+
+func (m *Marshaler) writeSep(out *errWriter) {
+	if m.Indent != "" {
+		out.write(",\n")
+	} else {
+		out.write(",")
+	}
+}
+
+func (m *Marshaler) marshalAny(out *errWriter, any proto.Message, indent string) error {
+	// "If the Any contains a value that has a special JSON mapping,
+	//  it will be converted as follows: {"@type": xxx, "value": yyy}.
+	//  Otherwise, the value will be converted into a JSON object,
+	//  and the "@type" field will be inserted to indicate the actual data type."
+	v := reflect.ValueOf(any).Elem()
+	turl := v.Field(0).String()
+	val := v.Field(1).Bytes()
+
+	var msg proto.Message
+	var err error
+	if m.AnyResolver != nil {
+		msg, err = m.AnyResolver.Resolve(turl)
+	} else {
+		msg, err = defaultResolveAny(turl)
+	}
+	if err != nil {
+		return err
+	}
+
+	if err := proto.Unmarshal(val, msg); err != nil {
+		return err
+	}
+
+	if _, ok := msg.(wkt); ok {
+		out.write("{")
+		if m.Indent != "" {
+			out.write("\n")
+		}
+		if err := m.marshalTypeURL(out, indent, turl); err != nil {
+			return err
+		}
+		m.writeSep(out)
+		if m.Indent != "" {
+			out.write(indent)
+			out.write(m.Indent)
+			out.write(`"value": `)
+		} else {
+			out.write(`"value":`)
+		}
+		if err := m.marshalObject(out, msg, indent+m.Indent, ""); err != nil {
+			return err
+		}
+		if m.Indent != "" {
+			out.write("\n")
+			out.write(indent)
+		}
+		out.write("}")
+		return out.err
+	}
+
+	return m.marshalObject(out, msg, indent, turl)
+}
+
+func (m *Marshaler) marshalTypeURL(out *errWriter, indent, typeURL string) error {
+	if m.Indent != "" {
+		out.write(indent)
+		out.write(m.Indent)
+	}
+	out.write(`"@type":`)
+	if m.Indent != "" {
+		out.write(" ")
+	}
+	b, err := json.Marshal(typeURL)
+	if err != nil {
+		return err
+	}
+	out.write(string(b))
+	return out.err
+}
+
+// marshalField writes field description and value to the Writer.
+func (m *Marshaler) marshalField(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error {
+	if m.Indent != "" {
+		out.write(indent)
+		out.write(m.Indent)
+	}
+	out.write(`"`)
+	out.write(prop.JSONName)
+	out.write(`":`)
+	if m.Indent != "" {
+		out.write(" ")
+	}
+	if err := m.marshalValue(out, prop, v, indent); err != nil {
+		return err
+	}
+	return nil
+}
+
+// marshalValue writes the value to the Writer.
+func (m *Marshaler) marshalValue(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error {
+	var err error
+	v = reflect.Indirect(v)
+
+	// Handle nil pointer
+	if v.Kind() == reflect.Invalid {
+		out.write("null")
+		return out.err
+	}
+
+	// Handle repeated elements.
+	if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
+		out.write("[")
+		comma := ""
+		for i := 0; i < v.Len(); i++ {
+			sliceVal := v.Index(i)
+			out.write(comma)
+			if m.Indent != "" {
+				out.write("\n")
+				out.write(indent)
+				out.write(m.Indent)
+				out.write(m.Indent)
+			}
+			if err := m.marshalValue(out, prop, sliceVal, indent+m.Indent); err != nil {
+				return err
+			}
+			comma = ","
+		}
+		if m.Indent != "" {
+			out.write("\n")
+			out.write(indent)
+			out.write(m.Indent)
+		}
+		out.write("]")
+		return out.err
+	}
+
+	// Handle well-known types.
+	// Most are handled up in marshalObject (because 99% are messages).
+	if wkt, ok := v.Interface().(wkt); ok {
+		switch wkt.XXX_WellKnownType() {
+		case "NullValue":
+			out.write("null")
+			return out.err
+		}
+	}
+
+	// Handle enumerations.
+	if !m.EnumsAsInts && prop.Enum != "" {
+		// Unknown enum values will are stringified by the proto library as their
+		// value. Such values should _not_ be quoted or they will be interpreted
+		// as an enum string instead of their value.
+		enumStr := v.Interface().(fmt.Stringer).String()
+		var valStr string
+		if v.Kind() == reflect.Ptr {
+			valStr = strconv.Itoa(int(v.Elem().Int()))
+		} else {
+			valStr = strconv.Itoa(int(v.Int()))
+		}
+		isKnownEnum := enumStr != valStr
+		if isKnownEnum {
+			out.write(`"`)
+		}
+		out.write(enumStr)
+		if isKnownEnum {
+			out.write(`"`)
+		}
+		return out.err
+	}
+
+	// Handle nested messages.
+	if v.Kind() == reflect.Struct {
+		return m.marshalObject(out, v.Addr().Interface().(proto.Message), indent+m.Indent, "")
+	}
+
+	// Handle maps.
+	// Since Go randomizes map iteration, we sort keys for stable output.
+	if v.Kind() == reflect.Map {
+		out.write(`{`)
+		keys := v.MapKeys()
+		sort.Sort(mapKeys(keys))
+		for i, k := range keys {
+			if i > 0 {
+				out.write(`,`)
+			}
+			if m.Indent != "" {
+				out.write("\n")
+				out.write(indent)
+				out.write(m.Indent)
+				out.write(m.Indent)
+			}
+
+			// TODO handle map key prop properly
+			b, err := json.Marshal(k.Interface())
+			if err != nil {
+				return err
+			}
+			s := string(b)
+
+			// If the JSON is not a string value, encode it again to make it one.
+			if !strings.HasPrefix(s, `"`) {
+				b, err := json.Marshal(s)
+				if err != nil {
+					return err
+				}
+				s = string(b)
+			}
+
+			out.write(s)
+			out.write(`:`)
+			if m.Indent != "" {
+				out.write(` `)
+			}
+
+			vprop := prop
+			if prop != nil && prop.MapValProp != nil {
+				vprop = prop.MapValProp
+			}
+			if err := m.marshalValue(out, vprop, v.MapIndex(k), indent+m.Indent); err != nil {
+				return err
+			}
+		}
+		if m.Indent != "" {
+			out.write("\n")
+			out.write(indent)
+			out.write(m.Indent)
+		}
+		out.write(`}`)
+		return out.err
+	}
+
+	// Handle non-finite floats, e.g. NaN, Infinity and -Infinity.
+	if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
+		f := v.Float()
+		var sval string
+		switch {
+		case math.IsInf(f, 1):
+			sval = `"Infinity"`
+		case math.IsInf(f, -1):
+			sval = `"-Infinity"`
+		case math.IsNaN(f):
+			sval = `"NaN"`
+		}
+		if sval != "" {
+			out.write(sval)
+			return out.err
+		}
+	}
+
+	// Default handling defers to the encoding/json library.
+	b, err := json.Marshal(v.Interface())
+	if err != nil {
+		return err
+	}
+	needToQuote := string(b[0]) != `"` && (v.Kind() == reflect.Int64 || v.Kind() == reflect.Uint64)
+	if needToQuote {
+		out.write(`"`)
+	}
+	out.write(string(b))
+	if needToQuote {
+		out.write(`"`)
+	}
+	return out.err
+}
+
+// Unmarshaler is a configurable object for converting from a JSON
+// representation to a protocol buffer object.
+type Unmarshaler struct {
+	// Whether to allow messages to contain unknown fields, as opposed to
+	// failing to unmarshal.
+	AllowUnknownFields bool
+
+	// A custom URL resolver to use when unmarshaling Any messages from JSON.
+	// If unset, the default resolution strategy is to extract the
+	// fully-qualified type name from the type URL and pass that to
+	// proto.MessageType(string).
+	AnyResolver AnyResolver
+}
+
+// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream.
+// This function is lenient and will decode any options permutations of the
+// related Marshaler.
+func (u *Unmarshaler) UnmarshalNext(dec *json.Decoder, pb proto.Message) error {
+	inputValue := json.RawMessage{}
+	if err := dec.Decode(&inputValue); err != nil {
+		return err
+	}
+	if err := u.unmarshalValue(reflect.ValueOf(pb).Elem(), inputValue, nil); err != nil {
+		return err
+	}
+	return checkRequiredFields(pb)
+}
+
+// Unmarshal unmarshals a JSON object stream into a protocol
+// buffer. This function is lenient and will decode any options
+// permutations of the related Marshaler.
+func (u *Unmarshaler) Unmarshal(r io.Reader, pb proto.Message) error {
+	dec := json.NewDecoder(r)
+	return u.UnmarshalNext(dec, pb)
+}
+
+// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream.
+// This function is lenient and will decode any options permutations of the
+// related Marshaler.
+func UnmarshalNext(dec *json.Decoder, pb proto.Message) error {
+	return new(Unmarshaler).UnmarshalNext(dec, pb)
+}
+
+// Unmarshal unmarshals a JSON object stream into a protocol
+// buffer. This function is lenient and will decode any options
+// permutations of the related Marshaler.
+func Unmarshal(r io.Reader, pb proto.Message) error {
+	return new(Unmarshaler).Unmarshal(r, pb)
+}
+
+// UnmarshalString will populate the fields of a protocol buffer based
+// on a JSON string. This function is lenient and will decode any options
+// permutations of the related Marshaler.
+func UnmarshalString(str string, pb proto.Message) error {
+	return new(Unmarshaler).Unmarshal(strings.NewReader(str), pb)
+}
+
+// unmarshalValue converts/copies a value into the target.
+// prop may be nil.
+func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMessage, prop *proto.Properties) error {
+	targetType := target.Type()
+
+	// Allocate memory for pointer fields.
+	if targetType.Kind() == reflect.Ptr {
+		// If input value is "null" and target is a pointer type, then the field should be treated as not set
+		// UNLESS the target is structpb.Value, in which case it should be set to structpb.NullValue.
+		_, isJSONPBUnmarshaler := target.Interface().(JSONPBUnmarshaler)
+		if string(inputValue) == "null" && targetType != reflect.TypeOf(&stpb.Value{}) && !isJSONPBUnmarshaler {
+			return nil
+		}
+		target.Set(reflect.New(targetType.Elem()))
+
+		return u.unmarshalValue(target.Elem(), inputValue, prop)
+	}
+
+	if jsu, ok := target.Addr().Interface().(JSONPBUnmarshaler); ok {
+		return jsu.UnmarshalJSONPB(u, []byte(inputValue))
+	}
+
+	// Handle well-known types that are not pointers.
+	if w, ok := target.Addr().Interface().(wkt); ok {
+		switch w.XXX_WellKnownType() {
+		case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value",
+			"Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue":
+			return u.unmarshalValue(target.Field(0), inputValue, prop)
+		case "Any":
+			// Use json.RawMessage pointer type instead of value to support pre-1.8 version.
+			// 1.8 changed RawMessage.MarshalJSON from pointer type to value type, see
+			// https://github.com/golang/go/issues/14493
+			var jsonFields map[string]*json.RawMessage
+			if err := json.Unmarshal(inputValue, &jsonFields); err != nil {
+				return err
+			}
+
+			val, ok := jsonFields["@type"]
+			if !ok || val == nil {
+				return errors.New("Any JSON doesn't have '@type'")
+			}
+
+			var turl string
+			if err := json.Unmarshal([]byte(*val), &turl); err != nil {
+				return fmt.Errorf("can't unmarshal Any's '@type': %q", *val)
+			}
+			target.Field(0).SetString(turl)
+
+			var m proto.Message
+			var err error
+			if u.AnyResolver != nil {
+				m, err = u.AnyResolver.Resolve(turl)
+			} else {
+				m, err = defaultResolveAny(turl)
+			}
+			if err != nil {
+				return err
+			}
+
+			if _, ok := m.(wkt); ok {
+				val, ok := jsonFields["value"]
+				if !ok {
+					return errors.New("Any JSON doesn't have 'value'")
+				}
+
+				if err := u.unmarshalValue(reflect.ValueOf(m).Elem(), *val, nil); err != nil {
+					return fmt.Errorf("can't unmarshal Any nested proto %T: %v", m, err)
+				}
+			} else {
+				delete(jsonFields, "@type")
+				nestedProto, err := json.Marshal(jsonFields)
+				if err != nil {
+					return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", err)
+				}
+
+				if err = u.unmarshalValue(reflect.ValueOf(m).Elem(), nestedProto, nil); err != nil {
+					return fmt.Errorf("can't unmarshal Any nested proto %T: %v", m, err)
+				}
+			}
+
+			b, err := proto.Marshal(m)
+			if err != nil {
+				return fmt.Errorf("can't marshal proto %T into Any.Value: %v", m, err)
+			}
+			target.Field(1).SetBytes(b)
+
+			return nil
+		case "Duration":
+			unq, err := unquote(string(inputValue))
+			if err != nil {
+				return err
+			}
+
+			d, err := time.ParseDuration(unq)
+			if err != nil {
+				return fmt.Errorf("bad Duration: %v", err)
+			}
+
+			ns := d.Nanoseconds()
+			s := ns / 1e9
+			ns %= 1e9
+			target.Field(0).SetInt(s)
+			target.Field(1).SetInt(ns)
+			return nil
+		case "Timestamp":
+			unq, err := unquote(string(inputValue))
+			if err != nil {
+				return err
+			}
+
+			t, err := time.Parse(time.RFC3339Nano, unq)
+			if err != nil {
+				return fmt.Errorf("bad Timestamp: %v", err)
+			}
+
+			target.Field(0).SetInt(t.Unix())
+			target.Field(1).SetInt(int64(t.Nanosecond()))
+			return nil
+		case "Struct":
+			var m map[string]json.RawMessage
+			if err := json.Unmarshal(inputValue, &m); err != nil {
+				return fmt.Errorf("bad StructValue: %v", err)
+			}
+
+			target.Field(0).Set(reflect.ValueOf(map[string]*stpb.Value{}))
+			for k, jv := range m {
+				pv := &stpb.Value{}
+				if err := u.unmarshalValue(reflect.ValueOf(pv).Elem(), jv, prop); err != nil {
+					return fmt.Errorf("bad value in StructValue for key %q: %v", k, err)
+				}
+				target.Field(0).SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(pv))
+			}
+			return nil
+		case "ListValue":
+			var s []json.RawMessage
+			if err := json.Unmarshal(inputValue, &s); err != nil {
+				return fmt.Errorf("bad ListValue: %v", err)
+			}
+
+			target.Field(0).Set(reflect.ValueOf(make([]*stpb.Value, len(s))))
+			for i, sv := range s {
+				if err := u.unmarshalValue(target.Field(0).Index(i), sv, prop); err != nil {
+					return err
+				}
+			}
+			return nil
+		case "Value":
+			ivStr := string(inputValue)
+			if ivStr == "null" {
+				target.Field(0).Set(reflect.ValueOf(&stpb.Value_NullValue{}))
+			} else if v, err := strconv.ParseFloat(ivStr, 0); err == nil {
+				target.Field(0).Set(reflect.ValueOf(&stpb.Value_NumberValue{v}))
+			} else if v, err := unquote(ivStr); err == nil {
+				target.Field(0).Set(reflect.ValueOf(&stpb.Value_StringValue{v}))
+			} else if v, err := strconv.ParseBool(ivStr); err == nil {
+				target.Field(0).Set(reflect.ValueOf(&stpb.Value_BoolValue{v}))
+			} else if err := json.Unmarshal(inputValue, &[]json.RawMessage{}); err == nil {
+				lv := &stpb.ListValue{}
+				target.Field(0).Set(reflect.ValueOf(&stpb.Value_ListValue{lv}))
+				return u.unmarshalValue(reflect.ValueOf(lv).Elem(), inputValue, prop)
+			} else if err := json.Unmarshal(inputValue, &map[string]json.RawMessage{}); err == nil {
+				sv := &stpb.Struct{}
+				target.Field(0).Set(reflect.ValueOf(&stpb.Value_StructValue{sv}))
+				return u.unmarshalValue(reflect.ValueOf(sv).Elem(), inputValue, prop)
+			} else {
+				return fmt.Errorf("unrecognized type for Value %q", ivStr)
+			}
+			return nil
+		}
+	}
+
+	// Handle enums, which have an underlying type of int32,
+	// and may appear as strings.
+	// The case of an enum appearing as a number is handled
+	// at the bottom of this function.
+	if inputValue[0] == '"' && prop != nil && prop.Enum != "" {
+		vmap := proto.EnumValueMap(prop.Enum)
+		// Don't need to do unquoting; valid enum names
+		// are from a limited character set.
+		s := inputValue[1 : len(inputValue)-1]
+		n, ok := vmap[string(s)]
+		if !ok {
+			return fmt.Errorf("unknown value %q for enum %s", s, prop.Enum)
+		}
+		if target.Kind() == reflect.Ptr { // proto2
+			target.Set(reflect.New(targetType.Elem()))
+			target = target.Elem()
+		}
+		if targetType.Kind() != reflect.Int32 {
+			return fmt.Errorf("invalid target %q for enum %s", targetType.Kind(), prop.Enum)
+		}
+		target.SetInt(int64(n))
+		return nil
+	}
+
+	// Handle nested messages.
+	if targetType.Kind() == reflect.Struct {
+		var jsonFields map[string]json.RawMessage
+		if err := json.Unmarshal(inputValue, &jsonFields); err != nil {
+			return err
+		}
+
+		consumeField := func(prop *proto.Properties) (json.RawMessage, bool) {
+			// Be liberal in what names we accept; both orig_name and camelName are okay.
+			fieldNames := acceptedJSONFieldNames(prop)
+
+			vOrig, okOrig := jsonFields[fieldNames.orig]
+			vCamel, okCamel := jsonFields[fieldNames.camel]
+			if !okOrig && !okCamel {
+				return nil, false
+			}
+			// If, for some reason, both are present in the data, favour the camelName.
+			var raw json.RawMessage
+			if okOrig {
+				raw = vOrig
+				delete(jsonFields, fieldNames.orig)
+			}
+			if okCamel {
+				raw = vCamel
+				delete(jsonFields, fieldNames.camel)
+			}
+			return raw, true
+		}
+
+		sprops := proto.GetProperties(targetType)
+		for i := 0; i < target.NumField(); i++ {
+			ft := target.Type().Field(i)
+			if strings.HasPrefix(ft.Name, "XXX_") {
+				continue
+			}
+
+			valueForField, ok := consumeField(sprops.Prop[i])
+			if !ok {
+				continue
+			}
+
+			if err := u.unmarshalValue(target.Field(i), valueForField, sprops.Prop[i]); err != nil {
+				return err
+			}
+		}
+		// Check for any oneof fields.
+		if len(jsonFields) > 0 {
+			for _, oop := range sprops.OneofTypes {
+				raw, ok := consumeField(oop.Prop)
+				if !ok {
+					continue
+				}
+				nv := reflect.New(oop.Type.Elem())
+				target.Field(oop.Field).Set(nv)
+				if err := u.unmarshalValue(nv.Elem().Field(0), raw, oop.Prop); err != nil {
+					return err
+				}
+			}
+		}
+		// Handle proto2 extensions.
+		if len(jsonFields) > 0 {
+			if ep, ok := target.Addr().Interface().(proto.Message); ok {
+				for _, ext := range proto.RegisteredExtensions(ep) {
+					name := fmt.Sprintf("[%s]", ext.Name)
+					raw, ok := jsonFields[name]
+					if !ok {
+						continue
+					}
+					delete(jsonFields, name)
+					nv := reflect.New(reflect.TypeOf(ext.ExtensionType).Elem())
+					if err := u.unmarshalValue(nv.Elem(), raw, nil); err != nil {
+						return err
+					}
+					if err := proto.SetExtension(ep, ext, nv.Interface()); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		if !u.AllowUnknownFields && len(jsonFields) > 0 {
+			// Pick any field to be the scapegoat.
+			var f string
+			for fname := range jsonFields {
+				f = fname
+				break
+			}
+			return fmt.Errorf("unknown field %q in %v", f, targetType)
+		}
+		return nil
+	}
+
+	// Handle arrays (which aren't encoded bytes)
+	if targetType.Kind() == reflect.Slice && targetType.Elem().Kind() != reflect.Uint8 {
+		var slc []json.RawMessage
+		if err := json.Unmarshal(inputValue, &slc); err != nil {
+			return err
+		}
+		if slc != nil {
+			l := len(slc)
+			target.Set(reflect.MakeSlice(targetType, l, l))
+			for i := 0; i < l; i++ {
+				if err := u.unmarshalValue(target.Index(i), slc[i], prop); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+
+	// Handle maps (whose keys are always strings)
+	if targetType.Kind() == reflect.Map {
+		var mp map[string]json.RawMessage
+		if err := json.Unmarshal(inputValue, &mp); err != nil {
+			return err
+		}
+		if mp != nil {
+			target.Set(reflect.MakeMap(targetType))
+			for ks, raw := range mp {
+				// Unmarshal map key. The core json library already decoded the key into a
+				// string, so we handle that specially. Other types were quoted post-serialization.
+				var k reflect.Value
+				if targetType.Key().Kind() == reflect.String {
+					k = reflect.ValueOf(ks)
+				} else {
+					k = reflect.New(targetType.Key()).Elem()
+					var kprop *proto.Properties
+					if prop != nil && prop.MapKeyProp != nil {
+						kprop = prop.MapKeyProp
+					}
+					if err := u.unmarshalValue(k, json.RawMessage(ks), kprop); err != nil {
+						return err
+					}
+				}
+
+				// Unmarshal map value.
+				v := reflect.New(targetType.Elem()).Elem()
+				var vprop *proto.Properties
+				if prop != nil && prop.MapValProp != nil {
+					vprop = prop.MapValProp
+				}
+				if err := u.unmarshalValue(v, raw, vprop); err != nil {
+					return err
+				}
+				target.SetMapIndex(k, v)
+			}
+		}
+		return nil
+	}
+
+	// Non-finite numbers can be encoded as strings.
+	isFloat := targetType.Kind() == reflect.Float32 || targetType.Kind() == reflect.Float64
+	if isFloat {
+		if num, ok := nonFinite[string(inputValue)]; ok {
+			target.SetFloat(num)
+			return nil
+		}
+	}
+
+	// integers & floats can be encoded as strings. In this case we drop
+	// the quotes and proceed as normal.
+	isNum := targetType.Kind() == reflect.Int64 || targetType.Kind() == reflect.Uint64 ||
+		targetType.Kind() == reflect.Int32 || targetType.Kind() == reflect.Uint32 ||
+		targetType.Kind() == reflect.Float32 || targetType.Kind() == reflect.Float64
+	if isNum && strings.HasPrefix(string(inputValue), `"`) {
+		inputValue = inputValue[1 : len(inputValue)-1]
+	}
+
+	// Use the encoding/json for parsing other value types.
+	return json.Unmarshal(inputValue, target.Addr().Interface())
+}
+
+func unquote(s string) (string, error) {
+	var ret string
+	err := json.Unmarshal([]byte(s), &ret)
+	return ret, err
+}
+
+// jsonProperties returns parsed proto.Properties for the field and corrects JSONName attribute.
+func jsonProperties(f reflect.StructField, origName bool) *proto.Properties {
+	var prop proto.Properties
+	prop.Init(f.Type, f.Name, f.Tag.Get("protobuf"), &f)
+	if origName || prop.JSONName == "" {
+		prop.JSONName = prop.OrigName
+	}
+	return &prop
+}
+
+type fieldNames struct {
+	orig, camel string
+}
+
+func acceptedJSONFieldNames(prop *proto.Properties) fieldNames {
+	opts := fieldNames{orig: prop.OrigName, camel: prop.OrigName}
+	if prop.JSONName != "" {
+		opts.camel = prop.JSONName
+	}
+	return opts
+}
+
+// Writer wrapper inspired by https://blog.golang.org/errors-are-values
+type errWriter struct {
+	writer io.Writer
+	err    error
+}
+
+func (w *errWriter) write(str string) {
+	if w.err != nil {
+		return
+	}
+	_, w.err = w.writer.Write([]byte(str))
+}
+
+// Map fields may have key types of non-float scalars, strings and enums.
+// The easiest way to sort them in some deterministic order is to use fmt.
+// If this turns out to be inefficient we can always consider other options,
+// such as doing a Schwartzian transform.
+//
+// Numeric keys are sorted in numeric order per
+// https://developers.google.com/protocol-buffers/docs/proto#maps.
+type mapKeys []reflect.Value
+
+func (s mapKeys) Len() int      { return len(s) }
+func (s mapKeys) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+func (s mapKeys) Less(i, j int) bool {
+	if k := s[i].Kind(); k == s[j].Kind() {
+		switch k {
+		case reflect.String:
+			return s[i].String() < s[j].String()
+		case reflect.Int32, reflect.Int64:
+			return s[i].Int() < s[j].Int()
+		case reflect.Uint32, reflect.Uint64:
+			return s[i].Uint() < s[j].Uint()
+		}
+	}
+	return fmt.Sprint(s[i].Interface()) < fmt.Sprint(s[j].Interface())
+}
+
+// checkRequiredFields returns an error if any required field in the given proto message is not set.
+// This function is used by both Marshal and Unmarshal.  While required fields only exist in a
+// proto2 message, a proto3 message can contain proto2 message(s).
+func checkRequiredFields(pb proto.Message) error {
+	// Most well-known type messages do not contain required fields.  The "Any" type may contain
+	// a message that has required fields.
+	//
+	// When an Any message is being marshaled, the code will invoked proto.Unmarshal on Any.Value
+	// field in order to transform that into JSON, and that should have returned an error if a
+	// required field is not set in the embedded message.
+	//
+	// When an Any message is being unmarshaled, the code will have invoked proto.Marshal on the
+	// embedded message to store the serialized message in Any.Value field, and that should have
+	// returned an error if a required field is not set.
+	if _, ok := pb.(wkt); ok {
+		return nil
+	}
+
+	v := reflect.ValueOf(pb)
+	// Skip message if it is not a struct pointer.
+	if v.Kind() != reflect.Ptr {
+		return nil
+	}
+	v = v.Elem()
+	if v.Kind() != reflect.Struct {
+		return nil
+	}
+
+	for i := 0; i < v.NumField(); i++ {
+		field := v.Field(i)
+		sfield := v.Type().Field(i)
+
+		if sfield.PkgPath != "" {
+			// blank PkgPath means the field is exported; skip if not exported
+			continue
+		}
+
+		if strings.HasPrefix(sfield.Name, "XXX_") {
+			continue
+		}
+
+		// Oneof field is an interface implemented by wrapper structs containing the actual oneof
+		// field, i.e. an interface containing &T{real_value}.
+		if sfield.Tag.Get("protobuf_oneof") != "" {
+			if field.Kind() != reflect.Interface {
+				continue
+			}
+			v := field.Elem()
+			if v.Kind() != reflect.Ptr || v.IsNil() {
+				continue
+			}
+			v = v.Elem()
+			if v.Kind() != reflect.Struct || v.NumField() < 1 {
+				continue
+			}
+			field = v.Field(0)
+			sfield = v.Type().Field(0)
+		}
+
+		protoTag := sfield.Tag.Get("protobuf")
+		if protoTag == "" {
+			continue
+		}
+		var prop proto.Properties
+		prop.Init(sfield.Type, sfield.Name, protoTag, &sfield)
+
+		switch field.Kind() {
+		case reflect.Map:
+			if field.IsNil() {
+				continue
+			}
+			// Check each map value.
+			keys := field.MapKeys()
+			for _, k := range keys {
+				v := field.MapIndex(k)
+				if err := checkRequiredFieldsInValue(v); err != nil {
+					return err
+				}
+			}
+		case reflect.Slice:
+			// Handle non-repeated type, e.g. bytes.
+			if !prop.Repeated {
+				if prop.Required && field.IsNil() {
+					return fmt.Errorf("required field %q is not set", prop.Name)
+				}
+				continue
+			}
+
+			// Handle repeated type.
+			if field.IsNil() {
+				continue
+			}
+			// Check each slice item.
+			for i := 0; i < field.Len(); i++ {
+				v := field.Index(i)
+				if err := checkRequiredFieldsInValue(v); err != nil {
+					return err
+				}
+			}
+		case reflect.Ptr:
+			if field.IsNil() {
+				if prop.Required {
+					return fmt.Errorf("required field %q is not set", prop.Name)
+				}
+				continue
+			}
+			if err := checkRequiredFieldsInValue(field); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Handle proto2 extensions.
+	for _, ext := range proto.RegisteredExtensions(pb) {
+		if !proto.HasExtension(pb, ext) {
+			continue
+		}
+		ep, err := proto.GetExtension(pb, ext)
+		if err != nil {
+			return err
+		}
+		err = checkRequiredFieldsInValue(reflect.ValueOf(ep))
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func checkRequiredFieldsInValue(v reflect.Value) error {
+	if pm, ok := v.Interface().(proto.Message); ok {
+		return checkRequiredFields(pm)
+	}
+	return nil
+}
diff --git a/vendor/github.com/golang/protobuf/proto/buffer.go b/vendor/github.com/golang/protobuf/proto/buffer.go
deleted file mode 100644
index e810e6f..0000000
--- a/vendor/github.com/golang/protobuf/proto/buffer.go
+++ /dev/null
@@ -1,324 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"errors"
-	"fmt"
-
-	"google.golang.org/protobuf/encoding/prototext"
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/runtime/protoimpl"
-)
-
-const (
-	WireVarint     = 0
-	WireFixed32    = 5
-	WireFixed64    = 1
-	WireBytes      = 2
-	WireStartGroup = 3
-	WireEndGroup   = 4
-)
-
-// EncodeVarint returns the varint encoded bytes of v.
-func EncodeVarint(v uint64) []byte {
-	return protowire.AppendVarint(nil, v)
-}
-
-// SizeVarint returns the length of the varint encoded bytes of v.
-// This is equal to len(EncodeVarint(v)).
-func SizeVarint(v uint64) int {
-	return protowire.SizeVarint(v)
-}
-
-// DecodeVarint parses a varint encoded integer from b,
-// returning the integer value and the length of the varint.
-// It returns (0, 0) if there is a parse error.
-func DecodeVarint(b []byte) (uint64, int) {
-	v, n := protowire.ConsumeVarint(b)
-	if n < 0 {
-		return 0, 0
-	}
-	return v, n
-}
-
-// Buffer is a buffer for encoding and decoding the protobuf wire format.
-// It may be reused between invocations to reduce memory usage.
-type Buffer struct {
-	buf           []byte
-	idx           int
-	deterministic bool
-}
-
-// NewBuffer allocates a new Buffer initialized with buf,
-// where the contents of buf are considered the unread portion of the buffer.
-func NewBuffer(buf []byte) *Buffer {
-	return &Buffer{buf: buf}
-}
-
-// SetDeterministic specifies whether to use deterministic serialization.
-//
-// Deterministic serialization guarantees that for a given binary, equal
-// messages will always be serialized to the same bytes. This implies:
-//
-//   - Repeated serialization of a message will return the same bytes.
-//   - Different processes of the same binary (which may be executing on
-//     different machines) will serialize equal messages to the same bytes.
-//
-// Note that the deterministic serialization is NOT canonical across
-// languages. It is not guaranteed to remain stable over time. It is unstable
-// across different builds with schema changes due to unknown fields.
-// Users who need canonical serialization (e.g., persistent storage in a
-// canonical form, fingerprinting, etc.) should define their own
-// canonicalization specification and implement their own serializer rather
-// than relying on this API.
-//
-// If deterministic serialization is requested, map entries will be sorted
-// by keys in lexographical order. This is an implementation detail and
-// subject to change.
-func (b *Buffer) SetDeterministic(deterministic bool) {
-	b.deterministic = deterministic
-}
-
-// SetBuf sets buf as the internal buffer,
-// where the contents of buf are considered the unread portion of the buffer.
-func (b *Buffer) SetBuf(buf []byte) {
-	b.buf = buf
-	b.idx = 0
-}
-
-// Reset clears the internal buffer of all written and unread data.
-func (b *Buffer) Reset() {
-	b.buf = b.buf[:0]
-	b.idx = 0
-}
-
-// Bytes returns the internal buffer.
-func (b *Buffer) Bytes() []byte {
-	return b.buf
-}
-
-// Unread returns the unread portion of the buffer.
-func (b *Buffer) Unread() []byte {
-	return b.buf[b.idx:]
-}
-
-// Marshal appends the wire-format encoding of m to the buffer.
-func (b *Buffer) Marshal(m Message) error {
-	var err error
-	b.buf, err = marshalAppend(b.buf, m, b.deterministic)
-	return err
-}
-
-// Unmarshal parses the wire-format message in the buffer and
-// places the decoded results in m.
-// It does not reset m before unmarshaling.
-func (b *Buffer) Unmarshal(m Message) error {
-	err := UnmarshalMerge(b.Unread(), m)
-	b.idx = len(b.buf)
-	return err
-}
-
-type unknownFields struct{ XXX_unrecognized protoimpl.UnknownFields }
-
-func (m *unknownFields) String() string { panic("not implemented") }
-func (m *unknownFields) Reset()         { panic("not implemented") }
-func (m *unknownFields) ProtoMessage()  { panic("not implemented") }
-
-// DebugPrint dumps the encoded bytes of b with a header and footer including s
-// to stdout. This is only intended for debugging.
-func (*Buffer) DebugPrint(s string, b []byte) {
-	m := MessageReflect(new(unknownFields))
-	m.SetUnknown(b)
-	b, _ = prototext.MarshalOptions{AllowPartial: true, Indent: "\t"}.Marshal(m.Interface())
-	fmt.Printf("==== %s ====\n%s==== %s ====\n", s, b, s)
-}
-
-// EncodeVarint appends an unsigned varint encoding to the buffer.
-func (b *Buffer) EncodeVarint(v uint64) error {
-	b.buf = protowire.AppendVarint(b.buf, v)
-	return nil
-}
-
-// EncodeZigzag32 appends a 32-bit zig-zag varint encoding to the buffer.
-func (b *Buffer) EncodeZigzag32(v uint64) error {
-	return b.EncodeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
-}
-
-// EncodeZigzag64 appends a 64-bit zig-zag varint encoding to the buffer.
-func (b *Buffer) EncodeZigzag64(v uint64) error {
-	return b.EncodeVarint(uint64((uint64(v) << 1) ^ uint64((int64(v) >> 63))))
-}
-
-// EncodeFixed32 appends a 32-bit little-endian integer to the buffer.
-func (b *Buffer) EncodeFixed32(v uint64) error {
-	b.buf = protowire.AppendFixed32(b.buf, uint32(v))
-	return nil
-}
-
-// EncodeFixed64 appends a 64-bit little-endian integer to the buffer.
-func (b *Buffer) EncodeFixed64(v uint64) error {
-	b.buf = protowire.AppendFixed64(b.buf, uint64(v))
-	return nil
-}
-
-// EncodeRawBytes appends a length-prefixed raw bytes to the buffer.
-func (b *Buffer) EncodeRawBytes(v []byte) error {
-	b.buf = protowire.AppendBytes(b.buf, v)
-	return nil
-}
-
-// EncodeStringBytes appends a length-prefixed raw bytes to the buffer.
-// It does not validate whether v contains valid UTF-8.
-func (b *Buffer) EncodeStringBytes(v string) error {
-	b.buf = protowire.AppendString(b.buf, v)
-	return nil
-}
-
-// EncodeMessage appends a length-prefixed encoded message to the buffer.
-func (b *Buffer) EncodeMessage(m Message) error {
-	var err error
-	b.buf = protowire.AppendVarint(b.buf, uint64(Size(m)))
-	b.buf, err = marshalAppend(b.buf, m, b.deterministic)
-	return err
-}
-
-// DecodeVarint consumes an encoded unsigned varint from the buffer.
-func (b *Buffer) DecodeVarint() (uint64, error) {
-	v, n := protowire.ConsumeVarint(b.buf[b.idx:])
-	if n < 0 {
-		return 0, protowire.ParseError(n)
-	}
-	b.idx += n
-	return uint64(v), nil
-}
-
-// DecodeZigzag32 consumes an encoded 32-bit zig-zag varint from the buffer.
-func (b *Buffer) DecodeZigzag32() (uint64, error) {
-	v, err := b.DecodeVarint()
-	if err != nil {
-		return 0, err
-	}
-	return uint64((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31)), nil
-}
-
-// DecodeZigzag64 consumes an encoded 64-bit zig-zag varint from the buffer.
-func (b *Buffer) DecodeZigzag64() (uint64, error) {
-	v, err := b.DecodeVarint()
-	if err != nil {
-		return 0, err
-	}
-	return uint64((uint64(v) >> 1) ^ uint64((int64(v&1)<<63)>>63)), nil
-}
-
-// DecodeFixed32 consumes a 32-bit little-endian integer from the buffer.
-func (b *Buffer) DecodeFixed32() (uint64, error) {
-	v, n := protowire.ConsumeFixed32(b.buf[b.idx:])
-	if n < 0 {
-		return 0, protowire.ParseError(n)
-	}
-	b.idx += n
-	return uint64(v), nil
-}
-
-// DecodeFixed64 consumes a 64-bit little-endian integer from the buffer.
-func (b *Buffer) DecodeFixed64() (uint64, error) {
-	v, n := protowire.ConsumeFixed64(b.buf[b.idx:])
-	if n < 0 {
-		return 0, protowire.ParseError(n)
-	}
-	b.idx += n
-	return uint64(v), nil
-}
-
-// DecodeRawBytes consumes a length-prefixed raw bytes from the buffer.
-// If alloc is specified, it returns a copy the raw bytes
-// rather than a sub-slice of the buffer.
-func (b *Buffer) DecodeRawBytes(alloc bool) ([]byte, error) {
-	v, n := protowire.ConsumeBytes(b.buf[b.idx:])
-	if n < 0 {
-		return nil, protowire.ParseError(n)
-	}
-	b.idx += n
-	if alloc {
-		v = append([]byte(nil), v...)
-	}
-	return v, nil
-}
-
-// DecodeStringBytes consumes a length-prefixed raw bytes from the buffer.
-// It does not validate whether the raw bytes contain valid UTF-8.
-func (b *Buffer) DecodeStringBytes() (string, error) {
-	v, n := protowire.ConsumeString(b.buf[b.idx:])
-	if n < 0 {
-		return "", protowire.ParseError(n)
-	}
-	b.idx += n
-	return v, nil
-}
-
-// DecodeMessage consumes a length-prefixed message from the buffer.
-// It does not reset m before unmarshaling.
-func (b *Buffer) DecodeMessage(m Message) error {
-	v, err := b.DecodeRawBytes(false)
-	if err != nil {
-		return err
-	}
-	return UnmarshalMerge(v, m)
-}
-
-// DecodeGroup consumes a message group from the buffer.
-// It assumes that the start group marker has already been consumed and
-// consumes all bytes until (and including the end group marker).
-// It does not reset m before unmarshaling.
-func (b *Buffer) DecodeGroup(m Message) error {
-	v, n, err := consumeGroup(b.buf[b.idx:])
-	if err != nil {
-		return err
-	}
-	b.idx += n
-	return UnmarshalMerge(v, m)
-}
-
-// consumeGroup parses b until it finds an end group marker, returning
-// the raw bytes of the message (excluding the end group marker) and the
-// the total length of the message (including the end group marker).
-func consumeGroup(b []byte) ([]byte, int, error) {
-	b0 := b
-	depth := 1 // assume this follows a start group marker
-	for {
-		_, wtyp, tagLen := protowire.ConsumeTag(b)
-		if tagLen < 0 {
-			return nil, 0, protowire.ParseError(tagLen)
-		}
-		b = b[tagLen:]
-
-		var valLen int
-		switch wtyp {
-		case protowire.VarintType:
-			_, valLen = protowire.ConsumeVarint(b)
-		case protowire.Fixed32Type:
-			_, valLen = protowire.ConsumeFixed32(b)
-		case protowire.Fixed64Type:
-			_, valLen = protowire.ConsumeFixed64(b)
-		case protowire.BytesType:
-			_, valLen = protowire.ConsumeBytes(b)
-		case protowire.StartGroupType:
-			depth++
-		case protowire.EndGroupType:
-			depth--
-		default:
-			return nil, 0, errors.New("proto: cannot parse reserved wire type")
-		}
-		if valLen < 0 {
-			return nil, 0, protowire.ParseError(valLen)
-		}
-		b = b[valLen:]
-
-		if depth == 0 {
-			return b0[:len(b0)-len(b)-tagLen], len(b0) - len(b), nil
-		}
-	}
-}
diff --git a/vendor/github.com/golang/protobuf/proto/clone.go b/vendor/github.com/golang/protobuf/proto/clone.go
new file mode 100644
index 0000000..3cd3249
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/clone.go
@@ -0,0 +1,253 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Protocol buffer deep copy and merge.
+// TODO: RawMessage.
+
+package proto
+
+import (
+	"fmt"
+	"log"
+	"reflect"
+	"strings"
+)
+
+// Clone returns a deep copy of a protocol buffer.
+func Clone(src Message) Message {
+	in := reflect.ValueOf(src)
+	if in.IsNil() {
+		return src
+	}
+	out := reflect.New(in.Type().Elem())
+	dst := out.Interface().(Message)
+	Merge(dst, src)
+	return dst
+}
+
+// Merger is the interface representing objects that can merge messages of the same type.
+type Merger interface {
+	// Merge merges src into this message.
+	// Required and optional fields that are set in src will be set to that value in dst.
+	// Elements of repeated fields will be appended.
+	//
+	// Merge may panic if called with a different argument type than the receiver.
+	Merge(src Message)
+}
+
+// generatedMerger is the custom merge method that generated protos will have.
+// We must add this method since a generate Merge method will conflict with
+// many existing protos that have a Merge data field already defined.
+type generatedMerger interface {
+	XXX_Merge(src Message)
+}
+
+// Merge merges src into dst.
+// Required and optional fields that are set in src will be set to that value in dst.
+// Elements of repeated fields will be appended.
+// Merge panics if src and dst are not the same type, or if dst is nil.
+func Merge(dst, src Message) {
+	if m, ok := dst.(Merger); ok {
+		m.Merge(src)
+		return
+	}
+
+	in := reflect.ValueOf(src)
+	out := reflect.ValueOf(dst)
+	if out.IsNil() {
+		panic("proto: nil destination")
+	}
+	if in.Type() != out.Type() {
+		panic(fmt.Sprintf("proto.Merge(%T, %T) type mismatch", dst, src))
+	}
+	if in.IsNil() {
+		return // Merge from nil src is a noop
+	}
+	if m, ok := dst.(generatedMerger); ok {
+		m.XXX_Merge(src)
+		return
+	}
+	mergeStruct(out.Elem(), in.Elem())
+}
+
+func mergeStruct(out, in reflect.Value) {
+	sprop := GetProperties(in.Type())
+	for i := 0; i < in.NumField(); i++ {
+		f := in.Type().Field(i)
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+		mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
+	}
+
+	if emIn, err := extendable(in.Addr().Interface()); err == nil {
+		emOut, _ := extendable(out.Addr().Interface())
+		mIn, muIn := emIn.extensionsRead()
+		if mIn != nil {
+			mOut := emOut.extensionsWrite()
+			muIn.Lock()
+			mergeExtension(mOut, mIn)
+			muIn.Unlock()
+		}
+	}
+
+	uf := in.FieldByName("XXX_unrecognized")
+	if !uf.IsValid() {
+		return
+	}
+	uin := uf.Bytes()
+	if len(uin) > 0 {
+		out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
+	}
+}
+
+// mergeAny performs a merge between two values of the same type.
+// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
+// prop is set if this is a struct field (it may be nil).
+func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
+	if in.Type() == protoMessageType {
+		if !in.IsNil() {
+			if out.IsNil() {
+				out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
+			} else {
+				Merge(out.Interface().(Message), in.Interface().(Message))
+			}
+		}
+		return
+	}
+	switch in.Kind() {
+	case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+		reflect.String, reflect.Uint32, reflect.Uint64:
+		if !viaPtr && isProto3Zero(in) {
+			return
+		}
+		out.Set(in)
+	case reflect.Interface:
+		// Probably a oneof field; copy non-nil values.
+		if in.IsNil() {
+			return
+		}
+		// Allocate destination if it is not set, or set to a different type.
+		// Otherwise we will merge as normal.
+		if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
+			out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
+		}
+		mergeAny(out.Elem(), in.Elem(), false, nil)
+	case reflect.Map:
+		if in.Len() == 0 {
+			return
+		}
+		if out.IsNil() {
+			out.Set(reflect.MakeMap(in.Type()))
+		}
+		// For maps with value types of *T or []byte we need to deep copy each value.
+		elemKind := in.Type().Elem().Kind()
+		for _, key := range in.MapKeys() {
+			var val reflect.Value
+			switch elemKind {
+			case reflect.Ptr:
+				val = reflect.New(in.Type().Elem().Elem())
+				mergeAny(val, in.MapIndex(key), false, nil)
+			case reflect.Slice:
+				val = in.MapIndex(key)
+				val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
+			default:
+				val = in.MapIndex(key)
+			}
+			out.SetMapIndex(key, val)
+		}
+	case reflect.Ptr:
+		if in.IsNil() {
+			return
+		}
+		if out.IsNil() {
+			out.Set(reflect.New(in.Elem().Type()))
+		}
+		mergeAny(out.Elem(), in.Elem(), true, nil)
+	case reflect.Slice:
+		if in.IsNil() {
+			return
+		}
+		if in.Type().Elem().Kind() == reflect.Uint8 {
+			// []byte is a scalar bytes field, not a repeated field.
+
+			// Edge case: if this is in a proto3 message, a zero length
+			// bytes field is considered the zero value, and should not
+			// be merged.
+			if prop != nil && prop.proto3 && in.Len() == 0 {
+				return
+			}
+
+			// Make a deep copy.
+			// Append to []byte{} instead of []byte(nil) so that we never end up
+			// with a nil result.
+			out.SetBytes(append([]byte{}, in.Bytes()...))
+			return
+		}
+		n := in.Len()
+		if out.IsNil() {
+			out.Set(reflect.MakeSlice(in.Type(), 0, n))
+		}
+		switch in.Type().Elem().Kind() {
+		case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+			reflect.String, reflect.Uint32, reflect.Uint64:
+			out.Set(reflect.AppendSlice(out, in))
+		default:
+			for i := 0; i < n; i++ {
+				x := reflect.Indirect(reflect.New(in.Type().Elem()))
+				mergeAny(x, in.Index(i), false, nil)
+				out.Set(reflect.Append(out, x))
+			}
+		}
+	case reflect.Struct:
+		mergeStruct(out, in)
+	default:
+		// unknown type, so not a protocol buffer
+		log.Printf("proto: don't know how to copy %v", in)
+	}
+}
+
+func mergeExtension(out, in map[int32]Extension) {
+	for extNum, eIn := range in {
+		eOut := Extension{desc: eIn.desc}
+		if eIn.value != nil {
+			v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
+			mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
+			eOut.value = v.Interface()
+		}
+		if eIn.enc != nil {
+			eOut.enc = make([]byte, len(eIn.enc))
+			copy(eOut.enc, eIn.enc)
+		}
+
+		out[extNum] = eOut
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go
new file mode 100644
index 0000000..63b0f08
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/decode.go
@@ -0,0 +1,427 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for decoding protocol buffer data to construct in-memory representations.
+ */
+
+import (
+	"errors"
+	"fmt"
+	"io"
+)
+
+// errOverflow is returned when an integer is too large to be represented.
+var errOverflow = errors.New("proto: integer overflow")
+
+// ErrInternalBadWireType is returned by generated code when an incorrect
+// wire type is encountered. It does not get returned to user code.
+var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
+
+// DecodeVarint reads a varint-encoded integer from the slice.
+// It returns the integer and the number of bytes consumed, or
+// zero if there is not enough.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func DecodeVarint(buf []byte) (x uint64, n int) {
+	for shift := uint(0); shift < 64; shift += 7 {
+		if n >= len(buf) {
+			return 0, 0
+		}
+		b := uint64(buf[n])
+		n++
+		x |= (b & 0x7F) << shift
+		if (b & 0x80) == 0 {
+			return x, n
+		}
+	}
+
+	// The number is too large to represent in a 64-bit value.
+	return 0, 0
+}
+
+func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
+	i := p.index
+	l := len(p.buf)
+
+	for shift := uint(0); shift < 64; shift += 7 {
+		if i >= l {
+			err = io.ErrUnexpectedEOF
+			return
+		}
+		b := p.buf[i]
+		i++
+		x |= (uint64(b) & 0x7F) << shift
+		if b < 0x80 {
+			p.index = i
+			return
+		}
+	}
+
+	// The number is too large to represent in a 64-bit value.
+	err = errOverflow
+	return
+}
+
+// DecodeVarint reads a varint-encoded integer from the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) DecodeVarint() (x uint64, err error) {
+	i := p.index
+	buf := p.buf
+
+	if i >= len(buf) {
+		return 0, io.ErrUnexpectedEOF
+	} else if buf[i] < 0x80 {
+		p.index++
+		return uint64(buf[i]), nil
+	} else if len(buf)-i < 10 {
+		return p.decodeVarintSlow()
+	}
+
+	var b uint64
+	// we already checked the first byte
+	x = uint64(buf[i]) - 0x80
+	i++
+
+	b = uint64(buf[i])
+	i++
+	x += b << 7
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 7
+
+	b = uint64(buf[i])
+	i++
+	x += b << 14
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 14
+
+	b = uint64(buf[i])
+	i++
+	x += b << 21
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 21
+
+	b = uint64(buf[i])
+	i++
+	x += b << 28
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 28
+
+	b = uint64(buf[i])
+	i++
+	x += b << 35
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 35
+
+	b = uint64(buf[i])
+	i++
+	x += b << 42
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 42
+
+	b = uint64(buf[i])
+	i++
+	x += b << 49
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 49
+
+	b = uint64(buf[i])
+	i++
+	x += b << 56
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 56
+
+	b = uint64(buf[i])
+	i++
+	x += b << 63
+	if b&0x80 == 0 {
+		goto done
+	}
+
+	return 0, errOverflow
+
+done:
+	p.index = i
+	return x, nil
+}
+
+// DecodeFixed64 reads a 64-bit integer from the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) DecodeFixed64() (x uint64, err error) {
+	// x, err already 0
+	i := p.index + 8
+	if i < 0 || i > len(p.buf) {
+		err = io.ErrUnexpectedEOF
+		return
+	}
+	p.index = i
+
+	x = uint64(p.buf[i-8])
+	x |= uint64(p.buf[i-7]) << 8
+	x |= uint64(p.buf[i-6]) << 16
+	x |= uint64(p.buf[i-5]) << 24
+	x |= uint64(p.buf[i-4]) << 32
+	x |= uint64(p.buf[i-3]) << 40
+	x |= uint64(p.buf[i-2]) << 48
+	x |= uint64(p.buf[i-1]) << 56
+	return
+}
+
+// DecodeFixed32 reads a 32-bit integer from the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) DecodeFixed32() (x uint64, err error) {
+	// x, err already 0
+	i := p.index + 4
+	if i < 0 || i > len(p.buf) {
+		err = io.ErrUnexpectedEOF
+		return
+	}
+	p.index = i
+
+	x = uint64(p.buf[i-4])
+	x |= uint64(p.buf[i-3]) << 8
+	x |= uint64(p.buf[i-2]) << 16
+	x |= uint64(p.buf[i-1]) << 24
+	return
+}
+
+// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
+// from the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
+	x, err = p.DecodeVarint()
+	if err != nil {
+		return
+	}
+	x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
+	return
+}
+
+// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
+// from  the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
+	x, err = p.DecodeVarint()
+	if err != nil {
+		return
+	}
+	x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
+	return
+}
+
+// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
+	n, err := p.DecodeVarint()
+	if err != nil {
+		return nil, err
+	}
+
+	nb := int(n)
+	if nb < 0 {
+		return nil, fmt.Errorf("proto: bad byte length %d", nb)
+	}
+	end := p.index + nb
+	if end < p.index || end > len(p.buf) {
+		return nil, io.ErrUnexpectedEOF
+	}
+
+	if !alloc {
+		// todo: check if can get more uses of alloc=false
+		buf = p.buf[p.index:end]
+		p.index += nb
+		return
+	}
+
+	buf = make([]byte, nb)
+	copy(buf, p.buf[p.index:])
+	p.index += nb
+	return
+}
+
+// DecodeStringBytes reads an encoded string from the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) DecodeStringBytes() (s string, err error) {
+	buf, err := p.DecodeRawBytes(false)
+	if err != nil {
+		return
+	}
+	return string(buf), nil
+}
+
+// Unmarshaler is the interface representing objects that can
+// unmarshal themselves.  The argument points to data that may be
+// overwritten, so implementations should not keep references to the
+// buffer.
+// Unmarshal implementations should not clear the receiver.
+// Any unmarshaled data should be merged into the receiver.
+// Callers of Unmarshal that do not want to retain existing data
+// should Reset the receiver before calling Unmarshal.
+type Unmarshaler interface {
+	Unmarshal([]byte) error
+}
+
+// newUnmarshaler is the interface representing objects that can
+// unmarshal themselves. The semantics are identical to Unmarshaler.
+//
+// This exists to support protoc-gen-go generated messages.
+// The proto package will stop type-asserting to this interface in the future.
+//
+// DO NOT DEPEND ON THIS.
+type newUnmarshaler interface {
+	XXX_Unmarshal([]byte) error
+}
+
+// Unmarshal parses the protocol buffer representation in buf and places the
+// decoded result in pb.  If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// Unmarshal resets pb before starting to unmarshal, so any
+// existing data in pb is always removed. Use UnmarshalMerge
+// to preserve and append to existing data.
+func Unmarshal(buf []byte, pb Message) error {
+	pb.Reset()
+	if u, ok := pb.(newUnmarshaler); ok {
+		return u.XXX_Unmarshal(buf)
+	}
+	if u, ok := pb.(Unmarshaler); ok {
+		return u.Unmarshal(buf)
+	}
+	return NewBuffer(buf).Unmarshal(pb)
+}
+
+// UnmarshalMerge parses the protocol buffer representation in buf and
+// writes the decoded result to pb.  If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// UnmarshalMerge merges into existing data in pb.
+// Most code should use Unmarshal instead.
+func UnmarshalMerge(buf []byte, pb Message) error {
+	if u, ok := pb.(newUnmarshaler); ok {
+		return u.XXX_Unmarshal(buf)
+	}
+	if u, ok := pb.(Unmarshaler); ok {
+		// NOTE: The history of proto have unfortunately been inconsistent
+		// whether Unmarshaler should or should not implicitly clear itself.
+		// Some implementations do, most do not.
+		// Thus, calling this here may or may not do what people want.
+		//
+		// See https://github.com/golang/protobuf/issues/424
+		return u.Unmarshal(buf)
+	}
+	return NewBuffer(buf).Unmarshal(pb)
+}
+
+// DecodeMessage reads a count-delimited message from the Buffer.
+func (p *Buffer) DecodeMessage(pb Message) error {
+	enc, err := p.DecodeRawBytes(false)
+	if err != nil {
+		return err
+	}
+	return NewBuffer(enc).Unmarshal(pb)
+}
+
+// DecodeGroup reads a tag-delimited group from the Buffer.
+// StartGroup tag is already consumed. This function consumes
+// EndGroup tag.
+func (p *Buffer) DecodeGroup(pb Message) error {
+	b := p.buf[p.index:]
+	x, y := findEndGroup(b)
+	if x < 0 {
+		return io.ErrUnexpectedEOF
+	}
+	err := Unmarshal(b[:x], pb)
+	p.index += y
+	return err
+}
+
+// Unmarshal parses the protocol buffer representation in the
+// Buffer and places the decoded result in pb.  If the struct
+// underlying pb does not match the data in the buffer, the results can be
+// unpredictable.
+//
+// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
+func (p *Buffer) Unmarshal(pb Message) error {
+	// If the object can unmarshal itself, let it.
+	if u, ok := pb.(newUnmarshaler); ok {
+		err := u.XXX_Unmarshal(p.buf[p.index:])
+		p.index = len(p.buf)
+		return err
+	}
+	if u, ok := pb.(Unmarshaler); ok {
+		// NOTE: The history of proto have unfortunately been inconsistent
+		// whether Unmarshaler should or should not implicitly clear itself.
+		// Some implementations do, most do not.
+		// Thus, calling this here may or may not do what people want.
+		//
+		// See https://github.com/golang/protobuf/issues/424
+		err := u.Unmarshal(p.buf[p.index:])
+		p.index = len(p.buf)
+		return err
+	}
+
+	// Slow workaround for messages that aren't Unmarshalers.
+	// This includes some hand-coded .pb.go files and
+	// bootstrap protos.
+	// TODO: fix all of those and then add Unmarshal to
+	// the Message interface. Then:
+	// The cast above and code below can be deleted.
+	// The old unmarshaler can be deleted.
+	// Clients can call Unmarshal directly (can already do that, actually).
+	var info InternalMessageInfo
+	err := info.Unmarshal(pb, p.buf[p.index:])
+	p.index = len(p.buf)
+	return err
+}
diff --git a/vendor/github.com/golang/protobuf/proto/defaults.go b/vendor/github.com/golang/protobuf/proto/defaults.go
deleted file mode 100644
index d399bf0..0000000
--- a/vendor/github.com/golang/protobuf/proto/defaults.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// SetDefaults sets unpopulated scalar fields to their default values.
-// Fields within a oneof are not set even if they have a default value.
-// SetDefaults is recursively called upon any populated message fields.
-func SetDefaults(m Message) {
-	if m != nil {
-		setDefaults(MessageReflect(m))
-	}
-}
-
-func setDefaults(m protoreflect.Message) {
-	fds := m.Descriptor().Fields()
-	for i := 0; i < fds.Len(); i++ {
-		fd := fds.Get(i)
-		if !m.Has(fd) {
-			if fd.HasDefault() && fd.ContainingOneof() == nil {
-				v := fd.Default()
-				if fd.Kind() == protoreflect.BytesKind {
-					v = protoreflect.ValueOf(append([]byte(nil), v.Bytes()...)) // copy the default bytes
-				}
-				m.Set(fd, v)
-			}
-			continue
-		}
-	}
-
-	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		switch {
-		// Handle singular message.
-		case fd.Cardinality() != protoreflect.Repeated:
-			if fd.Message() != nil {
-				setDefaults(m.Get(fd).Message())
-			}
-		// Handle list of messages.
-		case fd.IsList():
-			if fd.Message() != nil {
-				ls := m.Get(fd).List()
-				for i := 0; i < ls.Len(); i++ {
-					setDefaults(ls.Get(i).Message())
-				}
-			}
-		// Handle map of messages.
-		case fd.IsMap():
-			if fd.MapValue().Message() != nil {
-				ms := m.Get(fd).Map()
-				ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool {
-					setDefaults(v.Message())
-					return true
-				})
-			}
-		}
-		return true
-	})
-}
diff --git a/vendor/github.com/golang/protobuf/proto/deprecated.go b/vendor/github.com/golang/protobuf/proto/deprecated.go
index e8db57e..35b882c 100644
--- a/vendor/github.com/golang/protobuf/proto/deprecated.go
+++ b/vendor/github.com/golang/protobuf/proto/deprecated.go
@@ -1,113 +1,63 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2018 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 package proto
 
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strconv"
+import "errors"
 
-	protoV2 "google.golang.org/protobuf/proto"
-)
-
-var (
-	// Deprecated: No longer returned.
-	ErrNil = errors.New("proto: Marshal called with nil")
-
-	// Deprecated: No longer returned.
-	ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
-
-	// Deprecated: No longer returned.
-	ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
-)
-
-// Deprecated: Do not use.
+// Deprecated: do not use.
 type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 }
 
-// Deprecated: Do not use.
+// Deprecated: do not use.
 func GetStats() Stats { return Stats{} }
 
-// Deprecated: Do not use.
+// Deprecated: do not use.
 func MarshalMessageSet(interface{}) ([]byte, error) {
 	return nil, errors.New("proto: not implemented")
 }
 
-// Deprecated: Do not use.
+// Deprecated: do not use.
 func UnmarshalMessageSet([]byte, interface{}) error {
 	return errors.New("proto: not implemented")
 }
 
-// Deprecated: Do not use.
+// Deprecated: do not use.
 func MarshalMessageSetJSON(interface{}) ([]byte, error) {
 	return nil, errors.New("proto: not implemented")
 }
 
-// Deprecated: Do not use.
+// Deprecated: do not use.
 func UnmarshalMessageSetJSON([]byte, interface{}) error {
 	return errors.New("proto: not implemented")
 }
 
-// Deprecated: Do not use.
+// Deprecated: do not use.
 func RegisterMessageSetType(Message, int32, string) {}
-
-// Deprecated: Do not use.
-func EnumName(m map[int32]string, v int32) string {
-	s, ok := m[v]
-	if ok {
-		return s
-	}
-	return strconv.Itoa(int(v))
-}
-
-// Deprecated: Do not use.
-func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
-	if data[0] == '"' {
-		// New style: enums are strings.
-		var repr string
-		if err := json.Unmarshal(data, &repr); err != nil {
-			return -1, err
-		}
-		val, ok := m[repr]
-		if !ok {
-			return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
-		}
-		return val, nil
-	}
-	// Old style: enums are ints.
-	var val int32
-	if err := json.Unmarshal(data, &val); err != nil {
-		return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
-	}
-	return val, nil
-}
-
-// Deprecated: Do not use; this type existed for intenal-use only.
-type InternalMessageInfo struct{}
-
-// Deprecated: Do not use; this method existed for intenal-use only.
-func (*InternalMessageInfo) DiscardUnknown(m Message) {
-	DiscardUnknown(m)
-}
-
-// Deprecated: Do not use; this method existed for intenal-use only.
-func (*InternalMessageInfo) Marshal(b []byte, m Message, deterministic bool) ([]byte, error) {
-	return protoV2.MarshalOptions{Deterministic: deterministic}.MarshalAppend(b, MessageV2(m))
-}
-
-// Deprecated: Do not use; this method existed for intenal-use only.
-func (*InternalMessageInfo) Merge(dst, src Message) {
-	protoV2.Merge(MessageV2(dst), MessageV2(src))
-}
-
-// Deprecated: Do not use; this method existed for intenal-use only.
-func (*InternalMessageInfo) Size(m Message) int {
-	return protoV2.Size(MessageV2(m))
-}
-
-// Deprecated: Do not use; this method existed for intenal-use only.
-func (*InternalMessageInfo) Unmarshal(m Message, b []byte) error {
-	return protoV2.UnmarshalOptions{Merge: true}.Unmarshal(b, MessageV2(m))
-}
diff --git a/vendor/github.com/golang/protobuf/proto/discard.go b/vendor/github.com/golang/protobuf/proto/discard.go
index 2187e87..dea2617 100644
--- a/vendor/github.com/golang/protobuf/proto/discard.go
+++ b/vendor/github.com/golang/protobuf/proto/discard.go
@@ -1,13 +1,48 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2017 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 package proto
 
 import (
-	"google.golang.org/protobuf/reflect/protoreflect"
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+	"sync/atomic"
 )
 
+type generatedDiscarder interface {
+	XXX_DiscardUnknown()
+}
+
 // DiscardUnknown recursively discards all unknown fields from this message
 // and all embedded messages.
 //
@@ -16,43 +51,300 @@
 // marshal to be able to produce a message that continues to have those
 // unrecognized fields. To avoid this, DiscardUnknown is used to
 // explicitly clear the unknown fields after unmarshaling.
+//
+// For proto2 messages, the unknown fields of message extensions are only
+// discarded from messages that have been accessed via GetExtension.
 func DiscardUnknown(m Message) {
-	if m != nil {
-		discardUnknown(MessageReflect(m))
+	if m, ok := m.(generatedDiscarder); ok {
+		m.XXX_DiscardUnknown()
+		return
+	}
+	// TODO: Dynamically populate a InternalMessageInfo for legacy messages,
+	// but the master branch has no implementation for InternalMessageInfo,
+	// so it would be more work to replicate that approach.
+	discardLegacy(m)
+}
+
+// DiscardUnknown recursively discards all unknown fields.
+func (a *InternalMessageInfo) DiscardUnknown(m Message) {
+	di := atomicLoadDiscardInfo(&a.discard)
+	if di == nil {
+		di = getDiscardInfo(reflect.TypeOf(m).Elem())
+		atomicStoreDiscardInfo(&a.discard, di)
+	}
+	di.discard(toPointer(&m))
+}
+
+type discardInfo struct {
+	typ reflect.Type
+
+	initialized int32 // 0: only typ is valid, 1: everything is valid
+	lock        sync.Mutex
+
+	fields       []discardFieldInfo
+	unrecognized field
+}
+
+type discardFieldInfo struct {
+	field   field // Offset of field, guaranteed to be valid
+	discard func(src pointer)
+}
+
+var (
+	discardInfoMap  = map[reflect.Type]*discardInfo{}
+	discardInfoLock sync.Mutex
+)
+
+func getDiscardInfo(t reflect.Type) *discardInfo {
+	discardInfoLock.Lock()
+	defer discardInfoLock.Unlock()
+	di := discardInfoMap[t]
+	if di == nil {
+		di = &discardInfo{typ: t}
+		discardInfoMap[t] = di
+	}
+	return di
+}
+
+func (di *discardInfo) discard(src pointer) {
+	if src.isNil() {
+		return // Nothing to do.
+	}
+
+	if atomic.LoadInt32(&di.initialized) == 0 {
+		di.computeDiscardInfo()
+	}
+
+	for _, fi := range di.fields {
+		sfp := src.offset(fi.field)
+		fi.discard(sfp)
+	}
+
+	// For proto2 messages, only discard unknown fields in message extensions
+	// that have been accessed via GetExtension.
+	if em, err := extendable(src.asPointerTo(di.typ).Interface()); err == nil {
+		// Ignore lock since DiscardUnknown is not concurrency safe.
+		emm, _ := em.extensionsRead()
+		for _, mx := range emm {
+			if m, ok := mx.value.(Message); ok {
+				DiscardUnknown(m)
+			}
+		}
+	}
+
+	if di.unrecognized.IsValid() {
+		*src.offset(di.unrecognized).toBytes() = nil
 	}
 }
 
-func discardUnknown(m protoreflect.Message) {
-	m.Range(func(fd protoreflect.FieldDescriptor, val protoreflect.Value) bool {
-		switch {
-		// Handle singular message.
-		case fd.Cardinality() != protoreflect.Repeated:
-			if fd.Message() != nil {
-				discardUnknown(m.Get(fd).Message())
-			}
-		// Handle list of messages.
-		case fd.IsList():
-			if fd.Message() != nil {
-				ls := m.Get(fd).List()
-				for i := 0; i < ls.Len(); i++ {
-					discardUnknown(ls.Get(i).Message())
+func (di *discardInfo) computeDiscardInfo() {
+	di.lock.Lock()
+	defer di.lock.Unlock()
+	if di.initialized != 0 {
+		return
+	}
+	t := di.typ
+	n := t.NumField()
+
+	for i := 0; i < n; i++ {
+		f := t.Field(i)
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+
+		dfi := discardFieldInfo{field: toField(&f)}
+		tf := f.Type
+
+		// Unwrap tf to get its most basic type.
+		var isPointer, isSlice bool
+		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
+			isSlice = true
+			tf = tf.Elem()
+		}
+		if tf.Kind() == reflect.Ptr {
+			isPointer = true
+			tf = tf.Elem()
+		}
+		if isPointer && isSlice && tf.Kind() != reflect.Struct {
+			panic(fmt.Sprintf("%v.%s cannot be a slice of pointers to primitive types", t, f.Name))
+		}
+
+		switch tf.Kind() {
+		case reflect.Struct:
+			switch {
+			case !isPointer:
+				panic(fmt.Sprintf("%v.%s cannot be a direct struct value", t, f.Name))
+			case isSlice: // E.g., []*pb.T
+				di := getDiscardInfo(tf)
+				dfi.discard = func(src pointer) {
+					sps := src.getPointerSlice()
+					for _, sp := range sps {
+						if !sp.isNil() {
+							di.discard(sp)
+						}
+					}
+				}
+			default: // E.g., *pb.T
+				di := getDiscardInfo(tf)
+				dfi.discard = func(src pointer) {
+					sp := src.getPointer()
+					if !sp.isNil() {
+						di.discard(sp)
+					}
 				}
 			}
-		// Handle map of messages.
-		case fd.IsMap():
-			if fd.MapValue().Message() != nil {
-				ms := m.Get(fd).Map()
-				ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool {
-					discardUnknown(v.Message())
-					return true
-				})
+		case reflect.Map:
+			switch {
+			case isPointer || isSlice:
+				panic(fmt.Sprintf("%v.%s cannot be a pointer to a map or a slice of map values", t, f.Name))
+			default: // E.g., map[K]V
+				if tf.Elem().Kind() == reflect.Ptr { // Proto struct (e.g., *T)
+					dfi.discard = func(src pointer) {
+						sm := src.asPointerTo(tf).Elem()
+						if sm.Len() == 0 {
+							return
+						}
+						for _, key := range sm.MapKeys() {
+							val := sm.MapIndex(key)
+							DiscardUnknown(val.Interface().(Message))
+						}
+					}
+				} else {
+					dfi.discard = func(pointer) {} // Noop
+				}
+			}
+		case reflect.Interface:
+			// Must be oneof field.
+			switch {
+			case isPointer || isSlice:
+				panic(fmt.Sprintf("%v.%s cannot be a pointer to a interface or a slice of interface values", t, f.Name))
+			default: // E.g., interface{}
+				// TODO: Make this faster?
+				dfi.discard = func(src pointer) {
+					su := src.asPointerTo(tf).Elem()
+					if !su.IsNil() {
+						sv := su.Elem().Elem().Field(0)
+						if sv.Kind() == reflect.Ptr && sv.IsNil() {
+							return
+						}
+						switch sv.Type().Kind() {
+						case reflect.Ptr: // Proto struct (e.g., *T)
+							DiscardUnknown(sv.Interface().(Message))
+						}
+					}
+				}
+			}
+		default:
+			continue
+		}
+		di.fields = append(di.fields, dfi)
+	}
+
+	di.unrecognized = invalidField
+	if f, ok := t.FieldByName("XXX_unrecognized"); ok {
+		if f.Type != reflect.TypeOf([]byte{}) {
+			panic("expected XXX_unrecognized to be of type []byte")
+		}
+		di.unrecognized = toField(&f)
+	}
+
+	atomic.StoreInt32(&di.initialized, 1)
+}
+
+func discardLegacy(m Message) {
+	v := reflect.ValueOf(m)
+	if v.Kind() != reflect.Ptr || v.IsNil() {
+		return
+	}
+	v = v.Elem()
+	if v.Kind() != reflect.Struct {
+		return
+	}
+	t := v.Type()
+
+	for i := 0; i < v.NumField(); i++ {
+		f := t.Field(i)
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+		vf := v.Field(i)
+		tf := f.Type
+
+		// Unwrap tf to get its most basic type.
+		var isPointer, isSlice bool
+		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
+			isSlice = true
+			tf = tf.Elem()
+		}
+		if tf.Kind() == reflect.Ptr {
+			isPointer = true
+			tf = tf.Elem()
+		}
+		if isPointer && isSlice && tf.Kind() != reflect.Struct {
+			panic(fmt.Sprintf("%T.%s cannot be a slice of pointers to primitive types", m, f.Name))
+		}
+
+		switch tf.Kind() {
+		case reflect.Struct:
+			switch {
+			case !isPointer:
+				panic(fmt.Sprintf("%T.%s cannot be a direct struct value", m, f.Name))
+			case isSlice: // E.g., []*pb.T
+				for j := 0; j < vf.Len(); j++ {
+					discardLegacy(vf.Index(j).Interface().(Message))
+				}
+			default: // E.g., *pb.T
+				discardLegacy(vf.Interface().(Message))
+			}
+		case reflect.Map:
+			switch {
+			case isPointer || isSlice:
+				panic(fmt.Sprintf("%T.%s cannot be a pointer to a map or a slice of map values", m, f.Name))
+			default: // E.g., map[K]V
+				tv := vf.Type().Elem()
+				if tv.Kind() == reflect.Ptr && tv.Implements(protoMessageType) { // Proto struct (e.g., *T)
+					for _, key := range vf.MapKeys() {
+						val := vf.MapIndex(key)
+						discardLegacy(val.Interface().(Message))
+					}
+				}
+			}
+		case reflect.Interface:
+			// Must be oneof field.
+			switch {
+			case isPointer || isSlice:
+				panic(fmt.Sprintf("%T.%s cannot be a pointer to a interface or a slice of interface values", m, f.Name))
+			default: // E.g., test_proto.isCommunique_Union interface
+				if !vf.IsNil() && f.Tag.Get("protobuf_oneof") != "" {
+					vf = vf.Elem() // E.g., *test_proto.Communique_Msg
+					if !vf.IsNil() {
+						vf = vf.Elem()   // E.g., test_proto.Communique_Msg
+						vf = vf.Field(0) // E.g., Proto struct (e.g., *T) or primitive value
+						if vf.Kind() == reflect.Ptr {
+							discardLegacy(vf.Interface().(Message))
+						}
+					}
+				}
 			}
 		}
-		return true
-	})
+	}
 
-	// Discard unknown fields.
-	if len(m.GetUnknown()) > 0 {
-		m.SetUnknown(nil)
+	if vf := v.FieldByName("XXX_unrecognized"); vf.IsValid() {
+		if vf.Type() != reflect.TypeOf([]byte{}) {
+			panic("expected XXX_unrecognized to be of type []byte")
+		}
+		vf.Set(reflect.ValueOf([]byte(nil)))
+	}
+
+	// For proto2 messages, only discard unknown fields in message extensions
+	// that have been accessed via GetExtension.
+	if em, err := extendable(m); err == nil {
+		// Ignore lock since discardLegacy is not concurrency safe.
+		emm, _ := em.extensionsRead()
+		for _, mx := range emm {
+			if m, ok := mx.value.(Message); ok {
+				discardLegacy(m)
+			}
+		}
 	}
 }
diff --git a/vendor/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/golang/protobuf/proto/encode.go
new file mode 100644
index 0000000..3abfed2
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/encode.go
@@ -0,0 +1,203 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
+import (
+	"errors"
+	"reflect"
+)
+
+var (
+	// errRepeatedHasNil is the error returned if Marshal is called with
+	// a struct with a repeated field containing a nil element.
+	errRepeatedHasNil = errors.New("proto: repeated field has nil element")
+
+	// errOneofHasNil is the error returned if Marshal is called with
+	// a struct with a oneof field containing a nil element.
+	errOneofHasNil = errors.New("proto: oneof field has nil value")
+
+	// ErrNil is the error returned if Marshal is called with nil.
+	ErrNil = errors.New("proto: Marshal called with nil")
+
+	// ErrTooLarge is the error returned if Marshal is called with a
+	// message that encodes to >2GB.
+	ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
+)
+
+// The fundamental encoders that put bytes on the wire.
+// Those that take integer types all accept uint64 and are
+// therefore of type valueEncoder.
+
+const maxVarintBytes = 10 // maximum length of a varint
+
+// EncodeVarint returns the varint encoding of x.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+// Not used by the package itself, but helpful to clients
+// wishing to use the same encoding.
+func EncodeVarint(x uint64) []byte {
+	var buf [maxVarintBytes]byte
+	var n int
+	for n = 0; x > 127; n++ {
+		buf[n] = 0x80 | uint8(x&0x7F)
+		x >>= 7
+	}
+	buf[n] = uint8(x)
+	n++
+	return buf[0:n]
+}
+
+// EncodeVarint writes a varint-encoded integer to the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) EncodeVarint(x uint64) error {
+	for x >= 1<<7 {
+		p.buf = append(p.buf, uint8(x&0x7f|0x80))
+		x >>= 7
+	}
+	p.buf = append(p.buf, uint8(x))
+	return nil
+}
+
+// SizeVarint returns the varint encoding size of an integer.
+func SizeVarint(x uint64) int {
+	switch {
+	case x < 1<<7:
+		return 1
+	case x < 1<<14:
+		return 2
+	case x < 1<<21:
+		return 3
+	case x < 1<<28:
+		return 4
+	case x < 1<<35:
+		return 5
+	case x < 1<<42:
+		return 6
+	case x < 1<<49:
+		return 7
+	case x < 1<<56:
+		return 8
+	case x < 1<<63:
+		return 9
+	}
+	return 10
+}
+
+// EncodeFixed64 writes a 64-bit integer to the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) EncodeFixed64(x uint64) error {
+	p.buf = append(p.buf,
+		uint8(x),
+		uint8(x>>8),
+		uint8(x>>16),
+		uint8(x>>24),
+		uint8(x>>32),
+		uint8(x>>40),
+		uint8(x>>48),
+		uint8(x>>56))
+	return nil
+}
+
+// EncodeFixed32 writes a 32-bit integer to the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) EncodeFixed32(x uint64) error {
+	p.buf = append(p.buf,
+		uint8(x),
+		uint8(x>>8),
+		uint8(x>>16),
+		uint8(x>>24))
+	return nil
+}
+
+// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
+// to the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) EncodeZigzag64(x uint64) error {
+	// use signed number to get arithmetic right shift.
+	return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+
+// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
+// to the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) EncodeZigzag32(x uint64) error {
+	// use signed number to get arithmetic right shift.
+	return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
+}
+
+// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) EncodeRawBytes(b []byte) error {
+	p.EncodeVarint(uint64(len(b)))
+	p.buf = append(p.buf, b...)
+	return nil
+}
+
+// EncodeStringBytes writes an encoded string to the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) EncodeStringBytes(s string) error {
+	p.EncodeVarint(uint64(len(s)))
+	p.buf = append(p.buf, s...)
+	return nil
+}
+
+// Marshaler is the interface representing objects that can marshal themselves.
+type Marshaler interface {
+	Marshal() ([]byte, error)
+}
+
+// EncodeMessage writes the protocol buffer to the Buffer,
+// prefixed by a varint-encoded length.
+func (p *Buffer) EncodeMessage(pb Message) error {
+	siz := Size(pb)
+	p.EncodeVarint(uint64(siz))
+	return p.Marshal(pb)
+}
+
+// All protocol buffer fields are nillable, but be careful.
+func isNil(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return v.IsNil()
+	}
+	return false
+}
diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.go
new file mode 100644
index 0000000..f9b6e41
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/equal.go
@@ -0,0 +1,301 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Protocol buffer comparison.
+
+package proto
+
+import (
+	"bytes"
+	"log"
+	"reflect"
+	"strings"
+)
+
+/*
+Equal returns true iff protocol buffers a and b are equal.
+The arguments must both be pointers to protocol buffer structs.
+
+Equality is defined in this way:
+  - Two messages are equal iff they are the same type,
+    corresponding fields are equal, unknown field sets
+    are equal, and extensions sets are equal.
+  - Two set scalar fields are equal iff their values are equal.
+    If the fields are of a floating-point type, remember that
+    NaN != x for all x, including NaN. If the message is defined
+    in a proto3 .proto file, fields are not "set"; specifically,
+    zero length proto3 "bytes" fields are equal (nil == {}).
+  - Two repeated fields are equal iff their lengths are the same,
+    and their corresponding elements are equal. Note a "bytes" field,
+    although represented by []byte, is not a repeated field and the
+    rule for the scalar fields described above applies.
+  - Two unset fields are equal.
+  - Two unknown field sets are equal if their current
+    encoded state is equal.
+  - Two extension sets are equal iff they have corresponding
+    elements that are pairwise equal.
+  - Two map fields are equal iff their lengths are the same,
+    and they contain the same set of elements. Zero-length map
+    fields are equal.
+  - Every other combination of things are not equal.
+
+The return value is undefined if a and b are not protocol buffers.
+*/
+func Equal(a, b Message) bool {
+	if a == nil || b == nil {
+		return a == b
+	}
+	v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
+	if v1.Type() != v2.Type() {
+		return false
+	}
+	if v1.Kind() == reflect.Ptr {
+		if v1.IsNil() {
+			return v2.IsNil()
+		}
+		if v2.IsNil() {
+			return false
+		}
+		v1, v2 = v1.Elem(), v2.Elem()
+	}
+	if v1.Kind() != reflect.Struct {
+		return false
+	}
+	return equalStruct(v1, v2)
+}
+
+// v1 and v2 are known to have the same type.
+func equalStruct(v1, v2 reflect.Value) bool {
+	sprop := GetProperties(v1.Type())
+	for i := 0; i < v1.NumField(); i++ {
+		f := v1.Type().Field(i)
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+		f1, f2 := v1.Field(i), v2.Field(i)
+		if f.Type.Kind() == reflect.Ptr {
+			if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
+				// both unset
+				continue
+			} else if n1 != n2 {
+				// set/unset mismatch
+				return false
+			}
+			f1, f2 = f1.Elem(), f2.Elem()
+		}
+		if !equalAny(f1, f2, sprop.Prop[i]) {
+			return false
+		}
+	}
+
+	if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
+		em2 := v2.FieldByName("XXX_InternalExtensions")
+		if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
+			return false
+		}
+	}
+
+	if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
+		em2 := v2.FieldByName("XXX_extensions")
+		if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
+			return false
+		}
+	}
+
+	uf := v1.FieldByName("XXX_unrecognized")
+	if !uf.IsValid() {
+		return true
+	}
+
+	u1 := uf.Bytes()
+	u2 := v2.FieldByName("XXX_unrecognized").Bytes()
+	return bytes.Equal(u1, u2)
+}
+
+// v1 and v2 are known to have the same type.
+// prop may be nil.
+func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
+	if v1.Type() == protoMessageType {
+		m1, _ := v1.Interface().(Message)
+		m2, _ := v2.Interface().(Message)
+		return Equal(m1, m2)
+	}
+	switch v1.Kind() {
+	case reflect.Bool:
+		return v1.Bool() == v2.Bool()
+	case reflect.Float32, reflect.Float64:
+		return v1.Float() == v2.Float()
+	case reflect.Int32, reflect.Int64:
+		return v1.Int() == v2.Int()
+	case reflect.Interface:
+		// Probably a oneof field; compare the inner values.
+		n1, n2 := v1.IsNil(), v2.IsNil()
+		if n1 || n2 {
+			return n1 == n2
+		}
+		e1, e2 := v1.Elem(), v2.Elem()
+		if e1.Type() != e2.Type() {
+			return false
+		}
+		return equalAny(e1, e2, nil)
+	case reflect.Map:
+		if v1.Len() != v2.Len() {
+			return false
+		}
+		for _, key := range v1.MapKeys() {
+			val2 := v2.MapIndex(key)
+			if !val2.IsValid() {
+				// This key was not found in the second map.
+				return false
+			}
+			if !equalAny(v1.MapIndex(key), val2, nil) {
+				return false
+			}
+		}
+		return true
+	case reflect.Ptr:
+		// Maps may have nil values in them, so check for nil.
+		if v1.IsNil() && v2.IsNil() {
+			return true
+		}
+		if v1.IsNil() != v2.IsNil() {
+			return false
+		}
+		return equalAny(v1.Elem(), v2.Elem(), prop)
+	case reflect.Slice:
+		if v1.Type().Elem().Kind() == reflect.Uint8 {
+			// short circuit: []byte
+
+			// Edge case: if this is in a proto3 message, a zero length
+			// bytes field is considered the zero value.
+			if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
+				return true
+			}
+			if v1.IsNil() != v2.IsNil() {
+				return false
+			}
+			return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
+		}
+
+		if v1.Len() != v2.Len() {
+			return false
+		}
+		for i := 0; i < v1.Len(); i++ {
+			if !equalAny(v1.Index(i), v2.Index(i), prop) {
+				return false
+			}
+		}
+		return true
+	case reflect.String:
+		return v1.Interface().(string) == v2.Interface().(string)
+	case reflect.Struct:
+		return equalStruct(v1, v2)
+	case reflect.Uint32, reflect.Uint64:
+		return v1.Uint() == v2.Uint()
+	}
+
+	// unknown type, so not a protocol buffer
+	log.Printf("proto: don't know how to compare %v", v1)
+	return false
+}
+
+// base is the struct type that the extensions are based on.
+// x1 and x2 are InternalExtensions.
+func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
+	em1, _ := x1.extensionsRead()
+	em2, _ := x2.extensionsRead()
+	return equalExtMap(base, em1, em2)
+}
+
+func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
+	if len(em1) != len(em2) {
+		return false
+	}
+
+	for extNum, e1 := range em1 {
+		e2, ok := em2[extNum]
+		if !ok {
+			return false
+		}
+
+		m1 := extensionAsLegacyType(e1.value)
+		m2 := extensionAsLegacyType(e2.value)
+
+		if m1 == nil && m2 == nil {
+			// Both have only encoded form.
+			if bytes.Equal(e1.enc, e2.enc) {
+				continue
+			}
+			// The bytes are different, but the extensions might still be
+			// equal. We need to decode them to compare.
+		}
+
+		if m1 != nil && m2 != nil {
+			// Both are unencoded.
+			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
+				return false
+			}
+			continue
+		}
+
+		// At least one is encoded. To do a semantically correct comparison
+		// we need to unmarshal them first.
+		var desc *ExtensionDesc
+		if m := extensionMaps[base]; m != nil {
+			desc = m[extNum]
+		}
+		if desc == nil {
+			// If both have only encoded form and the bytes are the same,
+			// it is handled above. We get here when the bytes are different.
+			// We don't know how to decode it, so just compare them as byte
+			// slices.
+			log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
+			return false
+		}
+		var err error
+		if m1 == nil {
+			m1, err = decodeExtension(e1.enc, desc)
+		}
+		if m2 == nil && err == nil {
+			m2, err = decodeExtension(e2.enc, desc)
+		}
+		if err != nil {
+			// The encoded form is invalid.
+			log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
+			return false
+		}
+		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
+			return false
+		}
+	}
+
+	return true
+}
diff --git a/vendor/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.go
index 42fc120..fa88add 100644
--- a/vendor/github.com/golang/protobuf/proto/extensions.go
+++ b/vendor/github.com/golang/protobuf/proto/extensions.go
@@ -1,356 +1,607 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 package proto
 
+/*
+ * Types and routines for supporting protocol buffer extensions.
+ */
+
 import (
 	"errors"
 	"fmt"
+	"io"
 	"reflect"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-	"google.golang.org/protobuf/runtime/protoiface"
-	"google.golang.org/protobuf/runtime/protoimpl"
+	"strconv"
+	"sync"
 )
 
-type (
-	// ExtensionDesc represents an extension descriptor and
-	// is used to interact with an extension field in a message.
-	//
-	// Variables of this type are generated in code by protoc-gen-go.
-	ExtensionDesc = protoimpl.ExtensionInfo
-
-	// ExtensionRange represents a range of message extensions.
-	// Used in code generated by protoc-gen-go.
-	ExtensionRange = protoiface.ExtensionRangeV1
-
-	// Deprecated: Do not use; this is an internal type.
-	Extension = protoimpl.ExtensionFieldV1
-
-	// Deprecated: Do not use; this is an internal type.
-	XXX_InternalExtensions = protoimpl.ExtensionFields
-)
-
-// ErrMissingExtension reports whether the extension was not present.
+// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
 var ErrMissingExtension = errors.New("proto: missing extension")
 
+// ExtensionRange represents a range of message extensions for a protocol buffer.
+// Used in code generated by the protocol compiler.
+type ExtensionRange struct {
+	Start, End int32 // both inclusive
+}
+
+// extendableProto is an interface implemented by any protocol buffer generated by the current
+// proto compiler that may be extended.
+type extendableProto interface {
+	Message
+	ExtensionRangeArray() []ExtensionRange
+	extensionsWrite() map[int32]Extension
+	extensionsRead() (map[int32]Extension, sync.Locker)
+}
+
+// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
+// version of the proto compiler that may be extended.
+type extendableProtoV1 interface {
+	Message
+	ExtensionRangeArray() []ExtensionRange
+	ExtensionMap() map[int32]Extension
+}
+
+// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
+type extensionAdapter struct {
+	extendableProtoV1
+}
+
+func (e extensionAdapter) extensionsWrite() map[int32]Extension {
+	return e.ExtensionMap()
+}
+
+func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
+	return e.ExtensionMap(), notLocker{}
+}
+
+// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
+type notLocker struct{}
+
+func (n notLocker) Lock()   {}
+func (n notLocker) Unlock() {}
+
+// extendable returns the extendableProto interface for the given generated proto message.
+// If the proto message has the old extension format, it returns a wrapper that implements
+// the extendableProto interface.
+func extendable(p interface{}) (extendableProto, error) {
+	switch p := p.(type) {
+	case extendableProto:
+		if isNilPtr(p) {
+			return nil, fmt.Errorf("proto: nil %T is not extendable", p)
+		}
+		return p, nil
+	case extendableProtoV1:
+		if isNilPtr(p) {
+			return nil, fmt.Errorf("proto: nil %T is not extendable", p)
+		}
+		return extensionAdapter{p}, nil
+	}
+	// Don't allocate a specific error containing %T:
+	// this is the hot path for Clone and MarshalText.
+	return nil, errNotExtendable
+}
+
 var errNotExtendable = errors.New("proto: not an extendable proto.Message")
 
-// HasExtension reports whether the extension field is present in m
-// either as an explicitly populated field or as an unknown field.
-func HasExtension(m Message, xt *ExtensionDesc) (has bool) {
-	mr := MessageReflect(m)
-	if mr == nil || !mr.IsValid() {
+func isNilPtr(x interface{}) bool {
+	v := reflect.ValueOf(x)
+	return v.Kind() == reflect.Ptr && v.IsNil()
+}
+
+// XXX_InternalExtensions is an internal representation of proto extensions.
+//
+// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
+// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
+//
+// The methods of XXX_InternalExtensions are not concurrency safe in general,
+// but calls to logically read-only methods such as has and get may be executed concurrently.
+type XXX_InternalExtensions struct {
+	// The struct must be indirect so that if a user inadvertently copies a
+	// generated message and its embedded XXX_InternalExtensions, they
+	// avoid the mayhem of a copied mutex.
+	//
+	// The mutex serializes all logically read-only operations to p.extensionMap.
+	// It is up to the client to ensure that write operations to p.extensionMap are
+	// mutually exclusive with other accesses.
+	p *struct {
+		mu           sync.Mutex
+		extensionMap map[int32]Extension
+	}
+}
+
+// extensionsWrite returns the extension map, creating it on first use.
+func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
+	if e.p == nil {
+		e.p = new(struct {
+			mu           sync.Mutex
+			extensionMap map[int32]Extension
+		})
+		e.p.extensionMap = make(map[int32]Extension)
+	}
+	return e.p.extensionMap
+}
+
+// extensionsRead returns the extensions map for read-only use.  It may be nil.
+// The caller must hold the returned mutex's lock when accessing Elements within the map.
+func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
+	if e.p == nil {
+		return nil, nil
+	}
+	return e.p.extensionMap, &e.p.mu
+}
+
+// ExtensionDesc represents an extension specification.
+// Used in generated code from the protocol compiler.
+type ExtensionDesc struct {
+	ExtendedType  Message     // nil pointer to the type that is being extended
+	ExtensionType interface{} // nil pointer to the extension type
+	Field         int32       // field number
+	Name          string      // fully-qualified name of extension, for text formatting
+	Tag           string      // protobuf tag style
+	Filename      string      // name of the file in which the extension is defined
+}
+
+func (ed *ExtensionDesc) repeated() bool {
+	t := reflect.TypeOf(ed.ExtensionType)
+	return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
+}
+
+// Extension represents an extension in a message.
+type Extension struct {
+	// When an extension is stored in a message using SetExtension
+	// only desc and value are set. When the message is marshaled
+	// enc will be set to the encoded form of the message.
+	//
+	// When a message is unmarshaled and contains extensions, each
+	// extension will have only enc set. When such an extension is
+	// accessed using GetExtension (or GetExtensions) desc and value
+	// will be set.
+	desc *ExtensionDesc
+
+	// value is a concrete value for the extension field. Let the type of
+	// desc.ExtensionType be the "API type" and the type of Extension.value
+	// be the "storage type". The API type and storage type are the same except:
+	//	* For scalars (except []byte), the API type uses *T,
+	//	while the storage type uses T.
+	//	* For repeated fields, the API type uses []T, while the storage type
+	//	uses *[]T.
+	//
+	// The reason for the divergence is so that the storage type more naturally
+	// matches what is expected of when retrieving the values through the
+	// protobuf reflection APIs.
+	//
+	// The value may only be populated if desc is also populated.
+	value interface{}
+
+	// enc is the raw bytes for the extension field.
+	enc []byte
+}
+
+// SetRawExtension is for testing only.
+func SetRawExtension(base Message, id int32, b []byte) {
+	epb, err := extendable(base)
+	if err != nil {
+		return
+	}
+	extmap := epb.extensionsWrite()
+	extmap[id] = Extension{enc: b}
+}
+
+// isExtensionField returns true iff the given field number is in an extension range.
+func isExtensionField(pb extendableProto, field int32) bool {
+	for _, er := range pb.ExtensionRangeArray() {
+		if er.Start <= field && field <= er.End {
+			return true
+		}
+	}
+	return false
+}
+
+// checkExtensionTypes checks that the given extension is valid for pb.
+func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
+	var pbi interface{} = pb
+	// Check the extended type.
+	if ea, ok := pbi.(extensionAdapter); ok {
+		pbi = ea.extendableProtoV1
+	}
+	if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
+		return fmt.Errorf("proto: bad extended type; %v does not extend %v", b, a)
+	}
+	// Check the range.
+	if !isExtensionField(pb, extension.Field) {
+		return errors.New("proto: bad extension number; not in declared ranges")
+	}
+	return nil
+}
+
+// extPropKey is sufficient to uniquely identify an extension.
+type extPropKey struct {
+	base  reflect.Type
+	field int32
+}
+
+var extProp = struct {
+	sync.RWMutex
+	m map[extPropKey]*Properties
+}{
+	m: make(map[extPropKey]*Properties),
+}
+
+func extensionProperties(ed *ExtensionDesc) *Properties {
+	key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
+
+	extProp.RLock()
+	if prop, ok := extProp.m[key]; ok {
+		extProp.RUnlock()
+		return prop
+	}
+	extProp.RUnlock()
+
+	extProp.Lock()
+	defer extProp.Unlock()
+	// Check again.
+	if prop, ok := extProp.m[key]; ok {
+		return prop
+	}
+
+	prop := new(Properties)
+	prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
+	extProp.m[key] = prop
+	return prop
+}
+
+// HasExtension returns whether the given extension is present in pb.
+func HasExtension(pb Message, extension *ExtensionDesc) bool {
+	// TODO: Check types, field numbers, etc.?
+	epb, err := extendable(pb)
+	if err != nil {
 		return false
 	}
-
-	// Check whether any populated known field matches the field number.
-	xtd := xt.TypeDescriptor()
-	if isValidExtension(mr.Descriptor(), xtd) {
-		has = mr.Has(xtd)
-	} else {
-		mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
-			has = int32(fd.Number()) == xt.Field
-			return !has
-		})
+	extmap, mu := epb.extensionsRead()
+	if extmap == nil {
+		return false
 	}
-
-	// Check whether any unknown field matches the field number.
-	for b := mr.GetUnknown(); !has && len(b) > 0; {
-		num, _, n := protowire.ConsumeField(b)
-		has = int32(num) == xt.Field
-		b = b[n:]
-	}
-	return has
+	mu.Lock()
+	_, ok := extmap[extension.Field]
+	mu.Unlock()
+	return ok
 }
 
-// ClearExtension removes the extension field from m
-// either as an explicitly populated field or as an unknown field.
-func ClearExtension(m Message, xt *ExtensionDesc) {
-	mr := MessageReflect(m)
-	if mr == nil || !mr.IsValid() {
+// ClearExtension removes the given extension from pb.
+func ClearExtension(pb Message, extension *ExtensionDesc) {
+	epb, err := extendable(pb)
+	if err != nil {
 		return
 	}
-
-	xtd := xt.TypeDescriptor()
-	if isValidExtension(mr.Descriptor(), xtd) {
-		mr.Clear(xtd)
-	} else {
-		mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
-			if int32(fd.Number()) == xt.Field {
-				mr.Clear(fd)
-				return false
-			}
-			return true
-		})
-	}
-	clearUnknown(mr, fieldNum(xt.Field))
+	// TODO: Check types, field numbers, etc.?
+	extmap := epb.extensionsWrite()
+	delete(extmap, extension.Field)
 }
 
-// ClearAllExtensions clears all extensions from m.
-// This includes populated fields and unknown fields in the extension range.
-func ClearAllExtensions(m Message) {
-	mr := MessageReflect(m)
-	if mr == nil || !mr.IsValid() {
-		return
-	}
-
-	mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
-		if fd.IsExtension() {
-			mr.Clear(fd)
-		}
-		return true
-	})
-	clearUnknown(mr, mr.Descriptor().ExtensionRanges())
-}
-
-// GetExtension retrieves a proto2 extended field from m.
+// GetExtension retrieves a proto2 extended field from pb.
 //
 // If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil),
 // then GetExtension parses the encoded field and returns a Go value of the specified type.
 // If the field is not present, then the default value is returned (if one is specified),
 // otherwise ErrMissingExtension is reported.
 //
-// If the descriptor is type incomplete (i.e., ExtensionDesc.ExtensionType is nil),
-// then GetExtension returns the raw encoded bytes for the extension field.
-func GetExtension(m Message, xt *ExtensionDesc) (interface{}, error) {
-	mr := MessageReflect(m)
-	if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
-		return nil, errNotExtendable
+// If the descriptor is not type complete (i.e., ExtensionDesc.ExtensionType is nil),
+// then GetExtension returns the raw encoded bytes of the field extension.
+func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
+	epb, err := extendable(pb)
+	if err != nil {
+		return nil, err
 	}
 
-	// Retrieve the unknown fields for this extension field.
-	var bo protoreflect.RawFields
-	for bi := mr.GetUnknown(); len(bi) > 0; {
-		num, _, n := protowire.ConsumeField(bi)
-		if int32(num) == xt.Field {
-			bo = append(bo, bi[:n]...)
-		}
-		bi = bi[n:]
-	}
-
-	// For type incomplete descriptors, only retrieve the unknown fields.
-	if xt.ExtensionType == nil {
-		return []byte(bo), nil
-	}
-
-	// If the extension field only exists as unknown fields, unmarshal it.
-	// This is rarely done since proto.Unmarshal eagerly unmarshals extensions.
-	xtd := xt.TypeDescriptor()
-	if !isValidExtension(mr.Descriptor(), xtd) {
-		return nil, fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m)
-	}
-	if !mr.Has(xtd) && len(bo) > 0 {
-		m2 := mr.New()
-		if err := (proto.UnmarshalOptions{
-			Resolver: extensionResolver{xt},
-		}.Unmarshal(bo, m2.Interface())); err != nil {
+	if extension.ExtendedType != nil {
+		// can only check type if this is a complete descriptor
+		if err := checkExtensionTypes(epb, extension); err != nil {
 			return nil, err
 		}
-		if m2.Has(xtd) {
-			mr.Set(xtd, m2.Get(xtd))
-			clearUnknown(mr, fieldNum(xt.Field))
-		}
 	}
 
-	// Check whether the message has the extension field set or a default.
-	var pv protoreflect.Value
-	switch {
-	case mr.Has(xtd):
-		pv = mr.Get(xtd)
-	case xtd.HasDefault():
-		pv = xtd.Default()
-	default:
+	emap, mu := epb.extensionsRead()
+	if emap == nil {
+		return defaultExtensionValue(extension)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	e, ok := emap[extension.Field]
+	if !ok {
+		// defaultExtensionValue returns the default value or
+		// ErrMissingExtension if there is no default.
+		return defaultExtensionValue(extension)
+	}
+
+	if e.value != nil {
+		// Already decoded. Check the descriptor, though.
+		if e.desc != extension {
+			// This shouldn't happen. If it does, it means that
+			// GetExtension was called twice with two different
+			// descriptors with the same field number.
+			return nil, errors.New("proto: descriptor conflict")
+		}
+		return extensionAsLegacyType(e.value), nil
+	}
+
+	if extension.ExtensionType == nil {
+		// incomplete descriptor
+		return e.enc, nil
+	}
+
+	v, err := decodeExtension(e.enc, extension)
+	if err != nil {
+		return nil, err
+	}
+
+	// Remember the decoded version and drop the encoded version.
+	// That way it is safe to mutate what we return.
+	e.value = extensionAsStorageType(v)
+	e.desc = extension
+	e.enc = nil
+	emap[extension.Field] = e
+	return extensionAsLegacyType(e.value), nil
+}
+
+// defaultExtensionValue returns the default value for extension.
+// If no default for an extension is defined ErrMissingExtension is returned.
+func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
+	if extension.ExtensionType == nil {
+		// incomplete descriptor, so no default
 		return nil, ErrMissingExtension
 	}
 
-	v := xt.InterfaceOf(pv)
-	rv := reflect.ValueOf(v)
-	if isScalarKind(rv.Kind()) {
-		rv2 := reflect.New(rv.Type())
-		rv2.Elem().Set(rv)
-		v = rv2.Interface()
+	t := reflect.TypeOf(extension.ExtensionType)
+	props := extensionProperties(extension)
+
+	sf, _, err := fieldDefault(t, props)
+	if err != nil {
+		return nil, err
 	}
-	return v, nil
+
+	if sf == nil || sf.value == nil {
+		// There is no default value.
+		return nil, ErrMissingExtension
+	}
+
+	if t.Kind() != reflect.Ptr {
+		// We do not need to return a Ptr, we can directly return sf.value.
+		return sf.value, nil
+	}
+
+	// We need to return an interface{} that is a pointer to sf.value.
+	value := reflect.New(t).Elem()
+	value.Set(reflect.New(value.Type().Elem()))
+	if sf.kind == reflect.Int32 {
+		// We may have an int32 or an enum, but the underlying data is int32.
+		// Since we can't set an int32 into a non int32 reflect.value directly
+		// set it as a int32.
+		value.Elem().SetInt(int64(sf.value.(int32)))
+	} else {
+		value.Elem().Set(reflect.ValueOf(sf.value))
+	}
+	return value.Interface(), nil
 }
 
-// extensionResolver is a custom extension resolver that stores a single
-// extension type that takes precedence over the global registry.
-type extensionResolver struct{ xt protoreflect.ExtensionType }
+// decodeExtension decodes an extension encoded in b.
+func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
+	t := reflect.TypeOf(extension.ExtensionType)
+	unmarshal := typeUnmarshaler(t, extension.Tag)
 
-func (r extensionResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
-	if xtd := r.xt.TypeDescriptor(); xtd.FullName() == field {
-		return r.xt, nil
-	}
-	return protoregistry.GlobalTypes.FindExtensionByName(field)
-}
+	// t is a pointer to a struct, pointer to basic type or a slice.
+	// Allocate space to store the pointer/slice.
+	value := reflect.New(t).Elem()
 
-func (r extensionResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
-	if xtd := r.xt.TypeDescriptor(); xtd.ContainingMessage().FullName() == message && xtd.Number() == field {
-		return r.xt, nil
-	}
-	return protoregistry.GlobalTypes.FindExtensionByNumber(message, field)
-}
+	var err error
+	for {
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		wire := int(x) & 7
 
-// GetExtensions returns a list of the extensions values present in m,
-// corresponding with the provided list of extension descriptors, xts.
-// If an extension is missing in m, the corresponding value is nil.
-func GetExtensions(m Message, xts []*ExtensionDesc) ([]interface{}, error) {
-	mr := MessageReflect(m)
-	if mr == nil || !mr.IsValid() {
-		return nil, errNotExtendable
-	}
-
-	vs := make([]interface{}, len(xts))
-	for i, xt := range xts {
-		v, err := GetExtension(m, xt)
+		b, err = unmarshal(b, valToPointer(value.Addr()), wire)
 		if err != nil {
-			if err == ErrMissingExtension {
-				continue
-			}
-			return vs, err
+			return nil, err
 		}
-		vs[i] = v
+
+		if len(b) == 0 {
+			break
+		}
 	}
-	return vs, nil
+	return value.Interface(), nil
 }
 
-// SetExtension sets an extension field in m to the provided value.
-func SetExtension(m Message, xt *ExtensionDesc, v interface{}) error {
-	mr := MessageReflect(m)
-	if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
-		return errNotExtendable
+// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
+// The returned slice has the same length as es; missing extensions will appear as nil elements.
+func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
+	epb, err := extendable(pb)
+	if err != nil {
+		return nil, err
 	}
-
-	rv := reflect.ValueOf(v)
-	if reflect.TypeOf(v) != reflect.TypeOf(xt.ExtensionType) {
-		return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", v, xt.ExtensionType)
-	}
-	if rv.Kind() == reflect.Ptr {
-		if rv.IsNil() {
-			return fmt.Errorf("proto: SetExtension called with nil value of type %T", v)
+	extensions = make([]interface{}, len(es))
+	for i, e := range es {
+		extensions[i], err = GetExtension(epb, e)
+		if err == ErrMissingExtension {
+			err = nil
 		}
-		if isScalarKind(rv.Elem().Kind()) {
-			v = rv.Elem().Interface()
+		if err != nil {
+			return
 		}
 	}
+	return
+}
 
-	xtd := xt.TypeDescriptor()
-	if !isValidExtension(mr.Descriptor(), xtd) {
-		return fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m)
+// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
+// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
+// just the Field field, which defines the extension's field number.
+func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
+	epb, err := extendable(pb)
+	if err != nil {
+		return nil, err
 	}
-	mr.Set(xtd, xt.ValueOf(v))
-	clearUnknown(mr, fieldNum(xt.Field))
+	registeredExtensions := RegisteredExtensions(pb)
+
+	emap, mu := epb.extensionsRead()
+	if emap == nil {
+		return nil, nil
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	extensions := make([]*ExtensionDesc, 0, len(emap))
+	for extid, e := range emap {
+		desc := e.desc
+		if desc == nil {
+			desc = registeredExtensions[extid]
+			if desc == nil {
+				desc = &ExtensionDesc{Field: extid}
+			}
+		}
+
+		extensions = append(extensions, desc)
+	}
+	return extensions, nil
+}
+
+// SetExtension sets the specified extension of pb to the specified value.
+func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
+	epb, err := extendable(pb)
+	if err != nil {
+		return err
+	}
+	if err := checkExtensionTypes(epb, extension); err != nil {
+		return err
+	}
+	typ := reflect.TypeOf(extension.ExtensionType)
+	if typ != reflect.TypeOf(value) {
+		return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", value, extension.ExtensionType)
+	}
+	// nil extension values need to be caught early, because the
+	// encoder can't distinguish an ErrNil due to a nil extension
+	// from an ErrNil due to a missing field. Extensions are
+	// always optional, so the encoder would just swallow the error
+	// and drop all the extensions from the encoded message.
+	if reflect.ValueOf(value).IsNil() {
+		return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
+	}
+
+	extmap := epb.extensionsWrite()
+	extmap[extension.Field] = Extension{desc: extension, value: extensionAsStorageType(value)}
 	return nil
 }
 
-// SetRawExtension inserts b into the unknown fields of m.
-//
-// Deprecated: Use Message.ProtoReflect.SetUnknown instead.
-func SetRawExtension(m Message, fnum int32, b []byte) {
-	mr := MessageReflect(m)
-	if mr == nil || !mr.IsValid() {
+// ClearAllExtensions clears all extensions from pb.
+func ClearAllExtensions(pb Message) {
+	epb, err := extendable(pb)
+	if err != nil {
 		return
 	}
-
-	// Verify that the raw field is valid.
-	for b0 := b; len(b0) > 0; {
-		num, _, n := protowire.ConsumeField(b0)
-		if int32(num) != fnum {
-			panic(fmt.Sprintf("mismatching field number: got %d, want %d", num, fnum))
-		}
-		b0 = b0[n:]
+	m := epb.extensionsWrite()
+	for k := range m {
+		delete(m, k)
 	}
-
-	ClearExtension(m, &ExtensionDesc{Field: fnum})
-	mr.SetUnknown(append(mr.GetUnknown(), b...))
 }
 
-// ExtensionDescs returns a list of extension descriptors found in m,
-// containing descriptors for both populated extension fields in m and
-// also unknown fields of m that are in the extension range.
-// For the later case, an type incomplete descriptor is provided where only
-// the ExtensionDesc.Field field is populated.
-// The order of the extension descriptors is undefined.
-func ExtensionDescs(m Message) ([]*ExtensionDesc, error) {
-	mr := MessageReflect(m)
-	if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 {
-		return nil, errNotExtendable
-	}
+// A global registry of extensions.
+// The generated code will register the generated descriptors by calling RegisterExtension.
 
-	// Collect a set of known extension descriptors.
-	extDescs := make(map[protoreflect.FieldNumber]*ExtensionDesc)
-	mr.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		if fd.IsExtension() {
-			xt := fd.(protoreflect.ExtensionTypeDescriptor)
-			if xd, ok := xt.Type().(*ExtensionDesc); ok {
-				extDescs[fd.Number()] = xd
+var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
+
+// RegisterExtension is called from the generated code.
+func RegisterExtension(desc *ExtensionDesc) {
+	st := reflect.TypeOf(desc.ExtendedType).Elem()
+	m := extensionMaps[st]
+	if m == nil {
+		m = make(map[int32]*ExtensionDesc)
+		extensionMaps[st] = m
+	}
+	if _, ok := m[desc.Field]; ok {
+		panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
+	}
+	m[desc.Field] = desc
+}
+
+// RegisteredExtensions returns a map of the registered extensions of a
+// protocol buffer struct, indexed by the extension number.
+// The argument pb should be a nil pointer to the struct type.
+func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
+	return extensionMaps[reflect.TypeOf(pb).Elem()]
+}
+
+// extensionAsLegacyType converts an value in the storage type as the API type.
+// See Extension.value.
+func extensionAsLegacyType(v interface{}) interface{} {
+	switch rv := reflect.ValueOf(v); rv.Kind() {
+	case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+		// Represent primitive types as a pointer to the value.
+		rv2 := reflect.New(rv.Type())
+		rv2.Elem().Set(rv)
+		v = rv2.Interface()
+	case reflect.Ptr:
+		// Represent slice types as the value itself.
+		switch rv.Type().Elem().Kind() {
+		case reflect.Slice:
+			if rv.IsNil() {
+				v = reflect.Zero(rv.Type().Elem()).Interface()
+			} else {
+				v = rv.Elem().Interface()
 			}
 		}
-		return true
-	})
+	}
+	return v
+}
 
-	// Collect a set of unknown extension descriptors.
-	extRanges := mr.Descriptor().ExtensionRanges()
-	for b := mr.GetUnknown(); len(b) > 0; {
-		num, _, n := protowire.ConsumeField(b)
-		if extRanges.Has(num) && extDescs[num] == nil {
-			extDescs[num] = nil
+// extensionAsStorageType converts an value in the API type as the storage type.
+// See Extension.value.
+func extensionAsStorageType(v interface{}) interface{} {
+	switch rv := reflect.ValueOf(v); rv.Kind() {
+	case reflect.Ptr:
+		// Represent slice types as the value itself.
+		switch rv.Type().Elem().Kind() {
+		case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+			if rv.IsNil() {
+				v = reflect.Zero(rv.Type().Elem()).Interface()
+			} else {
+				v = rv.Elem().Interface()
+			}
 		}
-		b = b[n:]
-	}
-
-	// Transpose the set of descriptors into a list.
-	var xts []*ExtensionDesc
-	for num, xt := range extDescs {
-		if xt == nil {
-			xt = &ExtensionDesc{Field: int32(num)}
+	case reflect.Slice:
+		// Represent slice types as a pointer to the value.
+		if rv.Type().Elem().Kind() != reflect.Uint8 {
+			rv2 := reflect.New(rv.Type())
+			rv2.Elem().Set(rv)
+			v = rv2.Interface()
 		}
-		xts = append(xts, xt)
 	}
-	return xts, nil
-}
-
-// isValidExtension reports whether xtd is a valid extension descriptor for md.
-func isValidExtension(md protoreflect.MessageDescriptor, xtd protoreflect.ExtensionTypeDescriptor) bool {
-	return xtd.ContainingMessage() == md && md.ExtensionRanges().Has(xtd.Number())
-}
-
-// isScalarKind reports whether k is a protobuf scalar kind (except bytes).
-// This function exists for historical reasons since the representation of
-// scalars differs between v1 and v2, where v1 uses *T and v2 uses T.
-func isScalarKind(k reflect.Kind) bool {
-	switch k {
-	case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
-		return true
-	default:
-		return false
-	}
-}
-
-// clearUnknown removes unknown fields from m where remover.Has reports true.
-func clearUnknown(m protoreflect.Message, remover interface {
-	Has(protoreflect.FieldNumber) bool
-}) {
-	var bo protoreflect.RawFields
-	for bi := m.GetUnknown(); len(bi) > 0; {
-		num, _, n := protowire.ConsumeField(bi)
-		if !remover.Has(num) {
-			bo = append(bo, bi[:n]...)
-		}
-		bi = bi[n:]
-	}
-	if bi := m.GetUnknown(); len(bi) != len(bo) {
-		m.SetUnknown(bo)
-	}
-}
-
-type fieldNum protoreflect.FieldNumber
-
-func (n1 fieldNum) Has(n2 protoreflect.FieldNumber) bool {
-	return protoreflect.FieldNumber(n1) == n2
+	return v
 }
diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go
new file mode 100644
index 0000000..fdd328b
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/lib.go
@@ -0,0 +1,965 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/*
+Package proto converts data structures to and from the wire format of
+protocol buffers.  It works in concert with the Go source code generated
+for .proto files by the protocol compiler.
+
+A summary of the properties of the protocol buffer interface
+for a protocol buffer variable v:
+
+  - Names are turned from camel_case to CamelCase for export.
+  - There are no methods on v to set fields; just treat
+	them as structure fields.
+  - There are getters that return a field's value if set,
+	and return the field's default value if unset.
+	The getters work even if the receiver is a nil message.
+  - The zero value for a struct is its correct initialization state.
+	All desired fields must be set before marshaling.
+  - A Reset() method will restore a protobuf struct to its zero state.
+  - Non-repeated fields are pointers to the values; nil means unset.
+	That is, optional or required field int32 f becomes F *int32.
+  - Repeated fields are slices.
+  - Helper functions are available to aid the setting of fields.
+	msg.Foo = proto.String("hello") // set field
+  - Constants are defined to hold the default values of all fields that
+	have them.  They have the form Default_StructName_FieldName.
+	Because the getter methods handle defaulted values,
+	direct use of these constants should be rare.
+  - Enums are given type names and maps from names to values.
+	Enum values are prefixed by the enclosing message's name, or by the
+	enum's type name if it is a top-level enum. Enum types have a String
+	method, and a Enum method to assist in message construction.
+  - Nested messages, groups and enums have type names prefixed with the name of
+	the surrounding message type.
+  - Extensions are given descriptor names that start with E_,
+	followed by an underscore-delimited list of the nested messages
+	that contain it (if any) followed by the CamelCased name of the
+	extension field itself.  HasExtension, ClearExtension, GetExtension
+	and SetExtension are functions for manipulating extensions.
+  - Oneof field sets are given a single field in their message,
+	with distinguished wrapper types for each possible field value.
+  - Marshal and Unmarshal are functions to encode and decode the wire format.
+
+When the .proto file specifies `syntax="proto3"`, there are some differences:
+
+  - Non-repeated fields of non-message type are values instead of pointers.
+  - Enum types do not get an Enum method.
+
+The simplest way to describe this is to see an example.
+Given file test.proto, containing
+
+	package example;
+
+	enum FOO { X = 17; }
+
+	message Test {
+	  required string label = 1;
+	  optional int32 type = 2 [default=77];
+	  repeated int64 reps = 3;
+	  optional group OptionalGroup = 4 {
+	    required string RequiredField = 5;
+	  }
+	  oneof union {
+	    int32 number = 6;
+	    string name = 7;
+	  }
+	}
+
+The resulting file, test.pb.go, is:
+
+	package example
+
+	import proto "github.com/golang/protobuf/proto"
+	import math "math"
+
+	type FOO int32
+	const (
+		FOO_X FOO = 17
+	)
+	var FOO_name = map[int32]string{
+		17: "X",
+	}
+	var FOO_value = map[string]int32{
+		"X": 17,
+	}
+
+	func (x FOO) Enum() *FOO {
+		p := new(FOO)
+		*p = x
+		return p
+	}
+	func (x FOO) String() string {
+		return proto.EnumName(FOO_name, int32(x))
+	}
+	func (x *FOO) UnmarshalJSON(data []byte) error {
+		value, err := proto.UnmarshalJSONEnum(FOO_value, data)
+		if err != nil {
+			return err
+		}
+		*x = FOO(value)
+		return nil
+	}
+
+	type Test struct {
+		Label         *string             `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
+		Type          *int32              `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
+		Reps          []int64             `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
+		Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
+		// Types that are valid to be assigned to Union:
+		//	*Test_Number
+		//	*Test_Name
+		Union            isTest_Union `protobuf_oneof:"union"`
+		XXX_unrecognized []byte       `json:"-"`
+	}
+	func (m *Test) Reset()         { *m = Test{} }
+	func (m *Test) String() string { return proto.CompactTextString(m) }
+	func (*Test) ProtoMessage() {}
+
+	type isTest_Union interface {
+		isTest_Union()
+	}
+
+	type Test_Number struct {
+		Number int32 `protobuf:"varint,6,opt,name=number"`
+	}
+	type Test_Name struct {
+		Name string `protobuf:"bytes,7,opt,name=name"`
+	}
+
+	func (*Test_Number) isTest_Union() {}
+	func (*Test_Name) isTest_Union()   {}
+
+	func (m *Test) GetUnion() isTest_Union {
+		if m != nil {
+			return m.Union
+		}
+		return nil
+	}
+	const Default_Test_Type int32 = 77
+
+	func (m *Test) GetLabel() string {
+		if m != nil && m.Label != nil {
+			return *m.Label
+		}
+		return ""
+	}
+
+	func (m *Test) GetType() int32 {
+		if m != nil && m.Type != nil {
+			return *m.Type
+		}
+		return Default_Test_Type
+	}
+
+	func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
+		if m != nil {
+			return m.Optionalgroup
+		}
+		return nil
+	}
+
+	type Test_OptionalGroup struct {
+		RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
+	}
+	func (m *Test_OptionalGroup) Reset()         { *m = Test_OptionalGroup{} }
+	func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
+
+	func (m *Test_OptionalGroup) GetRequiredField() string {
+		if m != nil && m.RequiredField != nil {
+			return *m.RequiredField
+		}
+		return ""
+	}
+
+	func (m *Test) GetNumber() int32 {
+		if x, ok := m.GetUnion().(*Test_Number); ok {
+			return x.Number
+		}
+		return 0
+	}
+
+	func (m *Test) GetName() string {
+		if x, ok := m.GetUnion().(*Test_Name); ok {
+			return x.Name
+		}
+		return ""
+	}
+
+	func init() {
+		proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
+	}
+
+To create and play with a Test object:
+
+	package main
+
+	import (
+		"log"
+
+		"github.com/golang/protobuf/proto"
+		pb "./example.pb"
+	)
+
+	func main() {
+		test := &pb.Test{
+			Label: proto.String("hello"),
+			Type:  proto.Int32(17),
+			Reps:  []int64{1, 2, 3},
+			Optionalgroup: &pb.Test_OptionalGroup{
+				RequiredField: proto.String("good bye"),
+			},
+			Union: &pb.Test_Name{"fred"},
+		}
+		data, err := proto.Marshal(test)
+		if err != nil {
+			log.Fatal("marshaling error: ", err)
+		}
+		newTest := &pb.Test{}
+		err = proto.Unmarshal(data, newTest)
+		if err != nil {
+			log.Fatal("unmarshaling error: ", err)
+		}
+		// Now test and newTest contain the same data.
+		if test.GetLabel() != newTest.GetLabel() {
+			log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
+		}
+		// Use a type switch to determine which oneof was set.
+		switch u := test.Union.(type) {
+		case *pb.Test_Number: // u.Number contains the number.
+		case *pb.Test_Name: // u.Name contains the string.
+		}
+		// etc.
+	}
+*/
+package proto
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"reflect"
+	"sort"
+	"strconv"
+	"sync"
+)
+
+// RequiredNotSetError is an error type returned by either Marshal or Unmarshal.
+// Marshal reports this when a required field is not initialized.
+// Unmarshal reports this when a required field is missing from the wire data.
+type RequiredNotSetError struct{ field string }
+
+func (e *RequiredNotSetError) Error() string {
+	if e.field == "" {
+		return fmt.Sprintf("proto: required field not set")
+	}
+	return fmt.Sprintf("proto: required field %q not set", e.field)
+}
+func (e *RequiredNotSetError) RequiredNotSet() bool {
+	return true
+}
+
+type invalidUTF8Error struct{ field string }
+
+func (e *invalidUTF8Error) Error() string {
+	if e.field == "" {
+		return "proto: invalid UTF-8 detected"
+	}
+	return fmt.Sprintf("proto: field %q contains invalid UTF-8", e.field)
+}
+func (e *invalidUTF8Error) InvalidUTF8() bool {
+	return true
+}
+
+// errInvalidUTF8 is a sentinel error to identify fields with invalid UTF-8.
+// This error should not be exposed to the external API as such errors should
+// be recreated with the field information.
+var errInvalidUTF8 = &invalidUTF8Error{}
+
+// isNonFatal reports whether the error is either a RequiredNotSet error
+// or a InvalidUTF8 error.
+func isNonFatal(err error) bool {
+	if re, ok := err.(interface{ RequiredNotSet() bool }); ok && re.RequiredNotSet() {
+		return true
+	}
+	if re, ok := err.(interface{ InvalidUTF8() bool }); ok && re.InvalidUTF8() {
+		return true
+	}
+	return false
+}
+
+type nonFatal struct{ E error }
+
+// Merge merges err into nf and reports whether it was successful.
+// Otherwise it returns false for any fatal non-nil errors.
+func (nf *nonFatal) Merge(err error) (ok bool) {
+	if err == nil {
+		return true // not an error
+	}
+	if !isNonFatal(err) {
+		return false // fatal error
+	}
+	if nf.E == nil {
+		nf.E = err // store first instance of non-fatal error
+	}
+	return true
+}
+
+// Message is implemented by generated protocol buffer messages.
+type Message interface {
+	Reset()
+	String() string
+	ProtoMessage()
+}
+
+// A Buffer is a buffer manager for marshaling and unmarshaling
+// protocol buffers.  It may be reused between invocations to
+// reduce memory usage.  It is not necessary to use a Buffer;
+// the global functions Marshal and Unmarshal create a
+// temporary Buffer and are fine for most applications.
+type Buffer struct {
+	buf   []byte // encode/decode byte stream
+	index int    // read point
+
+	deterministic bool
+}
+
+// NewBuffer allocates a new Buffer and initializes its internal data to
+// the contents of the argument slice.
+func NewBuffer(e []byte) *Buffer {
+	return &Buffer{buf: e}
+}
+
+// Reset resets the Buffer, ready for marshaling a new protocol buffer.
+func (p *Buffer) Reset() {
+	p.buf = p.buf[0:0] // for reading/writing
+	p.index = 0        // for reading
+}
+
+// SetBuf replaces the internal buffer with the slice,
+// ready for unmarshaling the contents of the slice.
+func (p *Buffer) SetBuf(s []byte) {
+	p.buf = s
+	p.index = 0
+}
+
+// Bytes returns the contents of the Buffer.
+func (p *Buffer) Bytes() []byte { return p.buf }
+
+// SetDeterministic sets whether to use deterministic serialization.
+//
+// Deterministic serialization guarantees that for a given binary, equal
+// messages will always be serialized to the same bytes. This implies:
+//
+//   - Repeated serialization of a message will return the same bytes.
+//   - Different processes of the same binary (which may be executing on
+//     different machines) will serialize equal messages to the same bytes.
+//
+// Note that the deterministic serialization is NOT canonical across
+// languages. It is not guaranteed to remain stable over time. It is unstable
+// across different builds with schema changes due to unknown fields.
+// Users who need canonical serialization (e.g., persistent storage in a
+// canonical form, fingerprinting, etc.) should define their own
+// canonicalization specification and implement their own serializer rather
+// than relying on this API.
+//
+// If deterministic serialization is requested, map entries will be sorted
+// by keys in lexographical order. This is an implementation detail and
+// subject to change.
+func (p *Buffer) SetDeterministic(deterministic bool) {
+	p.deterministic = deterministic
+}
+
+/*
+ * Helper routines for simplifying the creation of optional fields of basic type.
+ */
+
+// Bool is a helper routine that allocates a new bool value
+// to store v and returns a pointer to it.
+func Bool(v bool) *bool {
+	return &v
+}
+
+// Int32 is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it.
+func Int32(v int32) *int32 {
+	return &v
+}
+
+// Int is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it, but unlike Int32
+// its argument value is an int.
+func Int(v int) *int32 {
+	p := new(int32)
+	*p = int32(v)
+	return p
+}
+
+// Int64 is a helper routine that allocates a new int64 value
+// to store v and returns a pointer to it.
+func Int64(v int64) *int64 {
+	return &v
+}
+
+// Float32 is a helper routine that allocates a new float32 value
+// to store v and returns a pointer to it.
+func Float32(v float32) *float32 {
+	return &v
+}
+
+// Float64 is a helper routine that allocates a new float64 value
+// to store v and returns a pointer to it.
+func Float64(v float64) *float64 {
+	return &v
+}
+
+// Uint32 is a helper routine that allocates a new uint32 value
+// to store v and returns a pointer to it.
+func Uint32(v uint32) *uint32 {
+	return &v
+}
+
+// Uint64 is a helper routine that allocates a new uint64 value
+// to store v and returns a pointer to it.
+func Uint64(v uint64) *uint64 {
+	return &v
+}
+
+// String is a helper routine that allocates a new string value
+// to store v and returns a pointer to it.
+func String(v string) *string {
+	return &v
+}
+
+// EnumName is a helper function to simplify printing protocol buffer enums
+// by name.  Given an enum map and a value, it returns a useful string.
+func EnumName(m map[int32]string, v int32) string {
+	s, ok := m[v]
+	if ok {
+		return s
+	}
+	return strconv.Itoa(int(v))
+}
+
+// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
+// from their JSON-encoded representation. Given a map from the enum's symbolic
+// names to its int values, and a byte buffer containing the JSON-encoded
+// value, it returns an int32 that can be cast to the enum type by the caller.
+//
+// The function can deal with both JSON representations, numeric and symbolic.
+func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
+	if data[0] == '"' {
+		// New style: enums are strings.
+		var repr string
+		if err := json.Unmarshal(data, &repr); err != nil {
+			return -1, err
+		}
+		val, ok := m[repr]
+		if !ok {
+			return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
+		}
+		return val, nil
+	}
+	// Old style: enums are ints.
+	var val int32
+	if err := json.Unmarshal(data, &val); err != nil {
+		return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
+	}
+	return val, nil
+}
+
+// DebugPrint dumps the encoded data in b in a debugging format with a header
+// including the string s. Used in testing but made available for general debugging.
+func (p *Buffer) DebugPrint(s string, b []byte) {
+	var u uint64
+
+	obuf := p.buf
+	index := p.index
+	p.buf = b
+	p.index = 0
+	depth := 0
+
+	fmt.Printf("\n--- %s ---\n", s)
+
+out:
+	for {
+		for i := 0; i < depth; i++ {
+			fmt.Print("  ")
+		}
+
+		index := p.index
+		if index == len(p.buf) {
+			break
+		}
+
+		op, err := p.DecodeVarint()
+		if err != nil {
+			fmt.Printf("%3d: fetching op err %v\n", index, err)
+			break out
+		}
+		tag := op >> 3
+		wire := op & 7
+
+		switch wire {
+		default:
+			fmt.Printf("%3d: t=%3d unknown wire=%d\n",
+				index, tag, wire)
+			break out
+
+		case WireBytes:
+			var r []byte
+
+			r, err = p.DecodeRawBytes(false)
+			if err != nil {
+				break out
+			}
+			fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
+			if len(r) <= 6 {
+				for i := 0; i < len(r); i++ {
+					fmt.Printf(" %.2x", r[i])
+				}
+			} else {
+				for i := 0; i < 3; i++ {
+					fmt.Printf(" %.2x", r[i])
+				}
+				fmt.Printf(" ..")
+				for i := len(r) - 3; i < len(r); i++ {
+					fmt.Printf(" %.2x", r[i])
+				}
+			}
+			fmt.Printf("\n")
+
+		case WireFixed32:
+			u, err = p.DecodeFixed32()
+			if err != nil {
+				fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
+
+		case WireFixed64:
+			u, err = p.DecodeFixed64()
+			if err != nil {
+				fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
+
+		case WireVarint:
+			u, err = p.DecodeVarint()
+			if err != nil {
+				fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
+
+		case WireStartGroup:
+			fmt.Printf("%3d: t=%3d start\n", index, tag)
+			depth++
+
+		case WireEndGroup:
+			depth--
+			fmt.Printf("%3d: t=%3d end\n", index, tag)
+		}
+	}
+
+	if depth != 0 {
+		fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
+	}
+	fmt.Printf("\n")
+
+	p.buf = obuf
+	p.index = index
+}
+
+// SetDefaults sets unset protocol buffer fields to their default values.
+// It only modifies fields that are both unset and have defined defaults.
+// It recursively sets default values in any non-nil sub-messages.
+func SetDefaults(pb Message) {
+	setDefaults(reflect.ValueOf(pb), true, false)
+}
+
+// v is a pointer to a struct.
+func setDefaults(v reflect.Value, recur, zeros bool) {
+	v = v.Elem()
+
+	defaultMu.RLock()
+	dm, ok := defaults[v.Type()]
+	defaultMu.RUnlock()
+	if !ok {
+		dm = buildDefaultMessage(v.Type())
+		defaultMu.Lock()
+		defaults[v.Type()] = dm
+		defaultMu.Unlock()
+	}
+
+	for _, sf := range dm.scalars {
+		f := v.Field(sf.index)
+		if !f.IsNil() {
+			// field already set
+			continue
+		}
+		dv := sf.value
+		if dv == nil && !zeros {
+			// no explicit default, and don't want to set zeros
+			continue
+		}
+		fptr := f.Addr().Interface() // **T
+		// TODO: Consider batching the allocations we do here.
+		switch sf.kind {
+		case reflect.Bool:
+			b := new(bool)
+			if dv != nil {
+				*b = dv.(bool)
+			}
+			*(fptr.(**bool)) = b
+		case reflect.Float32:
+			f := new(float32)
+			if dv != nil {
+				*f = dv.(float32)
+			}
+			*(fptr.(**float32)) = f
+		case reflect.Float64:
+			f := new(float64)
+			if dv != nil {
+				*f = dv.(float64)
+			}
+			*(fptr.(**float64)) = f
+		case reflect.Int32:
+			// might be an enum
+			if ft := f.Type(); ft != int32PtrType {
+				// enum
+				f.Set(reflect.New(ft.Elem()))
+				if dv != nil {
+					f.Elem().SetInt(int64(dv.(int32)))
+				}
+			} else {
+				// int32 field
+				i := new(int32)
+				if dv != nil {
+					*i = dv.(int32)
+				}
+				*(fptr.(**int32)) = i
+			}
+		case reflect.Int64:
+			i := new(int64)
+			if dv != nil {
+				*i = dv.(int64)
+			}
+			*(fptr.(**int64)) = i
+		case reflect.String:
+			s := new(string)
+			if dv != nil {
+				*s = dv.(string)
+			}
+			*(fptr.(**string)) = s
+		case reflect.Uint8:
+			// exceptional case: []byte
+			var b []byte
+			if dv != nil {
+				db := dv.([]byte)
+				b = make([]byte, len(db))
+				copy(b, db)
+			} else {
+				b = []byte{}
+			}
+			*(fptr.(*[]byte)) = b
+		case reflect.Uint32:
+			u := new(uint32)
+			if dv != nil {
+				*u = dv.(uint32)
+			}
+			*(fptr.(**uint32)) = u
+		case reflect.Uint64:
+			u := new(uint64)
+			if dv != nil {
+				*u = dv.(uint64)
+			}
+			*(fptr.(**uint64)) = u
+		default:
+			log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
+		}
+	}
+
+	for _, ni := range dm.nested {
+		f := v.Field(ni)
+		// f is *T or []*T or map[T]*T
+		switch f.Kind() {
+		case reflect.Ptr:
+			if f.IsNil() {
+				continue
+			}
+			setDefaults(f, recur, zeros)
+
+		case reflect.Slice:
+			for i := 0; i < f.Len(); i++ {
+				e := f.Index(i)
+				if e.IsNil() {
+					continue
+				}
+				setDefaults(e, recur, zeros)
+			}
+
+		case reflect.Map:
+			for _, k := range f.MapKeys() {
+				e := f.MapIndex(k)
+				if e.IsNil() {
+					continue
+				}
+				setDefaults(e, recur, zeros)
+			}
+		}
+	}
+}
+
+var (
+	// defaults maps a protocol buffer struct type to a slice of the fields,
+	// with its scalar fields set to their proto-declared non-zero default values.
+	defaultMu sync.RWMutex
+	defaults  = make(map[reflect.Type]defaultMessage)
+
+	int32PtrType = reflect.TypeOf((*int32)(nil))
+)
+
+// defaultMessage represents information about the default values of a message.
+type defaultMessage struct {
+	scalars []scalarField
+	nested  []int // struct field index of nested messages
+}
+
+type scalarField struct {
+	index int          // struct field index
+	kind  reflect.Kind // element type (the T in *T or []T)
+	value interface{}  // the proto-declared default value, or nil
+}
+
+// t is a struct type.
+func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
+	sprop := GetProperties(t)
+	for _, prop := range sprop.Prop {
+		fi, ok := sprop.decoderTags.get(prop.Tag)
+		if !ok {
+			// XXX_unrecognized
+			continue
+		}
+		ft := t.Field(fi).Type
+
+		sf, nested, err := fieldDefault(ft, prop)
+		switch {
+		case err != nil:
+			log.Print(err)
+		case nested:
+			dm.nested = append(dm.nested, fi)
+		case sf != nil:
+			sf.index = fi
+			dm.scalars = append(dm.scalars, *sf)
+		}
+	}
+
+	return dm
+}
+
+// fieldDefault returns the scalarField for field type ft.
+// sf will be nil if the field can not have a default.
+// nestedMessage will be true if this is a nested message.
+// Note that sf.index is not set on return.
+func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
+	var canHaveDefault bool
+	switch ft.Kind() {
+	case reflect.Ptr:
+		if ft.Elem().Kind() == reflect.Struct {
+			nestedMessage = true
+		} else {
+			canHaveDefault = true // proto2 scalar field
+		}
+
+	case reflect.Slice:
+		switch ft.Elem().Kind() {
+		case reflect.Ptr:
+			nestedMessage = true // repeated message
+		case reflect.Uint8:
+			canHaveDefault = true // bytes field
+		}
+
+	case reflect.Map:
+		if ft.Elem().Kind() == reflect.Ptr {
+			nestedMessage = true // map with message values
+		}
+	}
+
+	if !canHaveDefault {
+		if nestedMessage {
+			return nil, true, nil
+		}
+		return nil, false, nil
+	}
+
+	// We now know that ft is a pointer or slice.
+	sf = &scalarField{kind: ft.Elem().Kind()}
+
+	// scalar fields without defaults
+	if !prop.HasDefault {
+		return sf, false, nil
+	}
+
+	// a scalar field: either *T or []byte
+	switch ft.Elem().Kind() {
+	case reflect.Bool:
+		x, err := strconv.ParseBool(prop.Default)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
+		}
+		sf.value = x
+	case reflect.Float32:
+		x, err := strconv.ParseFloat(prop.Default, 32)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
+		}
+		sf.value = float32(x)
+	case reflect.Float64:
+		x, err := strconv.ParseFloat(prop.Default, 64)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
+		}
+		sf.value = x
+	case reflect.Int32:
+		x, err := strconv.ParseInt(prop.Default, 10, 32)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
+		}
+		sf.value = int32(x)
+	case reflect.Int64:
+		x, err := strconv.ParseInt(prop.Default, 10, 64)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
+		}
+		sf.value = x
+	case reflect.String:
+		sf.value = prop.Default
+	case reflect.Uint8:
+		// []byte (not *uint8)
+		sf.value = []byte(prop.Default)
+	case reflect.Uint32:
+		x, err := strconv.ParseUint(prop.Default, 10, 32)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
+		}
+		sf.value = uint32(x)
+	case reflect.Uint64:
+		x, err := strconv.ParseUint(prop.Default, 10, 64)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
+		}
+		sf.value = x
+	default:
+		return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
+	}
+
+	return sf, false, nil
+}
+
+// mapKeys returns a sort.Interface to be used for sorting the map keys.
+// Map fields may have key types of non-float scalars, strings and enums.
+func mapKeys(vs []reflect.Value) sort.Interface {
+	s := mapKeySorter{vs: vs}
+
+	// Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps.
+	if len(vs) == 0 {
+		return s
+	}
+	switch vs[0].Kind() {
+	case reflect.Int32, reflect.Int64:
+		s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
+	case reflect.Uint32, reflect.Uint64:
+		s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
+	case reflect.Bool:
+		s.less = func(a, b reflect.Value) bool { return !a.Bool() && b.Bool() } // false < true
+	case reflect.String:
+		s.less = func(a, b reflect.Value) bool { return a.String() < b.String() }
+	default:
+		panic(fmt.Sprintf("unsupported map key type: %v", vs[0].Kind()))
+	}
+
+	return s
+}
+
+type mapKeySorter struct {
+	vs   []reflect.Value
+	less func(a, b reflect.Value) bool
+}
+
+func (s mapKeySorter) Len() int      { return len(s.vs) }
+func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
+func (s mapKeySorter) Less(i, j int) bool {
+	return s.less(s.vs[i], s.vs[j])
+}
+
+// isProto3Zero reports whether v is a zero proto3 value.
+func isProto3Zero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint32, reflect.Uint64:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.String:
+		return v.String() == ""
+	}
+	return false
+}
+
+const (
+	// ProtoPackageIsVersion3 is referenced from generated protocol buffer files
+	// to assert that that code is compatible with this version of the proto package.
+	ProtoPackageIsVersion3 = true
+
+	// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
+	// to assert that that code is compatible with this version of the proto package.
+	ProtoPackageIsVersion2 = true
+
+	// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
+	// to assert that that code is compatible with this version of the proto package.
+	ProtoPackageIsVersion1 = true
+)
+
+// InternalMessageInfo is a type used internally by generated .pb.go files.
+// This type is not intended to be used by non-generated code.
+// This type is not subject to any compatibility guarantee.
+type InternalMessageInfo struct {
+	marshal   *marshalInfo
+	unmarshal *unmarshalInfo
+	merge     *mergeInfo
+	discard   *discardInfo
+}
diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.go
new file mode 100644
index 0000000..f48a756
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/message_set.go
@@ -0,0 +1,181 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Support for message sets.
+ */
+
+import (
+	"errors"
+)
+
+// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
+// A message type ID is required for storing a protocol buffer in a message set.
+var errNoMessageTypeID = errors.New("proto does not have a message type ID")
+
+// The first two types (_MessageSet_Item and messageSet)
+// model what the protocol compiler produces for the following protocol message:
+//   message MessageSet {
+//     repeated group Item = 1 {
+//       required int32 type_id = 2;
+//       required string message = 3;
+//     };
+//   }
+// That is the MessageSet wire format. We can't use a proto to generate these
+// because that would introduce a circular dependency between it and this package.
+
+type _MessageSet_Item struct {
+	TypeId  *int32 `protobuf:"varint,2,req,name=type_id"`
+	Message []byte `protobuf:"bytes,3,req,name=message"`
+}
+
+type messageSet struct {
+	Item             []*_MessageSet_Item `protobuf:"group,1,rep"`
+	XXX_unrecognized []byte
+	// TODO: caching?
+}
+
+// Make sure messageSet is a Message.
+var _ Message = (*messageSet)(nil)
+
+// messageTypeIder is an interface satisfied by a protocol buffer type
+// that may be stored in a MessageSet.
+type messageTypeIder interface {
+	MessageTypeId() int32
+}
+
+func (ms *messageSet) find(pb Message) *_MessageSet_Item {
+	mti, ok := pb.(messageTypeIder)
+	if !ok {
+		return nil
+	}
+	id := mti.MessageTypeId()
+	for _, item := range ms.Item {
+		if *item.TypeId == id {
+			return item
+		}
+	}
+	return nil
+}
+
+func (ms *messageSet) Has(pb Message) bool {
+	return ms.find(pb) != nil
+}
+
+func (ms *messageSet) Unmarshal(pb Message) error {
+	if item := ms.find(pb); item != nil {
+		return Unmarshal(item.Message, pb)
+	}
+	if _, ok := pb.(messageTypeIder); !ok {
+		return errNoMessageTypeID
+	}
+	return nil // TODO: return error instead?
+}
+
+func (ms *messageSet) Marshal(pb Message) error {
+	msg, err := Marshal(pb)
+	if err != nil {
+		return err
+	}
+	if item := ms.find(pb); item != nil {
+		// reuse existing item
+		item.Message = msg
+		return nil
+	}
+
+	mti, ok := pb.(messageTypeIder)
+	if !ok {
+		return errNoMessageTypeID
+	}
+
+	mtid := mti.MessageTypeId()
+	ms.Item = append(ms.Item, &_MessageSet_Item{
+		TypeId:  &mtid,
+		Message: msg,
+	})
+	return nil
+}
+
+func (ms *messageSet) Reset()         { *ms = messageSet{} }
+func (ms *messageSet) String() string { return CompactTextString(ms) }
+func (*messageSet) ProtoMessage()     {}
+
+// Support for the message_set_wire_format message option.
+
+func skipVarint(buf []byte) []byte {
+	i := 0
+	for ; buf[i]&0x80 != 0; i++ {
+	}
+	return buf[i+1:]
+}
+
+// unmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
+// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
+func unmarshalMessageSet(buf []byte, exts interface{}) error {
+	var m map[int32]Extension
+	switch exts := exts.(type) {
+	case *XXX_InternalExtensions:
+		m = exts.extensionsWrite()
+	case map[int32]Extension:
+		m = exts
+	default:
+		return errors.New("proto: not an extension map")
+	}
+
+	ms := new(messageSet)
+	if err := Unmarshal(buf, ms); err != nil {
+		return err
+	}
+	for _, item := range ms.Item {
+		id := *item.TypeId
+		msg := item.Message
+
+		// Restore wire type and field number varint, plus length varint.
+		// Be careful to preserve duplicate items.
+		b := EncodeVarint(uint64(id)<<3 | WireBytes)
+		if ext, ok := m[id]; ok {
+			// Existing data; rip off the tag and length varint
+			// so we join the new data correctly.
+			// We can assume that ext.enc is set because we are unmarshaling.
+			o := ext.enc[len(b):]   // skip wire type and field number
+			_, n := DecodeVarint(o) // calculate length of length varint
+			o = o[n:]               // skip length varint
+			msg = append(o, msg...) // join old data and new data
+		}
+		b = append(b, EncodeVarint(uint64(len(msg)))...)
+		b = append(b, msg...)
+
+		m[id] = Extension{enc: b}
+	}
+	return nil
+}
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
new file mode 100644
index 0000000..94fa919
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
@@ -0,0 +1,360 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build purego appengine js
+
+// This file contains an implementation of proto field accesses using package reflect.
+// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
+// be used on App Engine.
+
+package proto
+
+import (
+	"reflect"
+	"sync"
+)
+
+const unsafeAllowed = false
+
+// A field identifies a field in a struct, accessible from a pointer.
+// In this implementation, a field is identified by the sequence of field indices
+// passed to reflect's FieldByIndex.
+type field []int
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+	return f.Index
+}
+
+// invalidField is an invalid field identifier.
+var invalidField = field(nil)
+
+// zeroField is a noop when calling pointer.offset.
+var zeroField = field([]int{})
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool { return f != nil }
+
+// The pointer type is for the table-driven decoder.
+// The implementation here uses a reflect.Value of pointer type to
+// create a generic pointer. In pointer_unsafe.go we use unsafe
+// instead of reflect to implement the same (but faster) interface.
+type pointer struct {
+	v reflect.Value
+}
+
+// toPointer converts an interface of pointer type to a pointer
+// that points to the same target.
+func toPointer(i *Message) pointer {
+	return pointer{v: reflect.ValueOf(*i)}
+}
+
+// toAddrPointer converts an interface to a pointer that points to
+// the interface data.
+func toAddrPointer(i *interface{}, isptr, deref bool) pointer {
+	v := reflect.ValueOf(*i)
+	u := reflect.New(v.Type())
+	u.Elem().Set(v)
+	if deref {
+		u = u.Elem()
+	}
+	return pointer{v: u}
+}
+
+// valToPointer converts v to a pointer.  v must be of pointer type.
+func valToPointer(v reflect.Value) pointer {
+	return pointer{v: v}
+}
+
+// offset converts from a pointer to a structure to a pointer to
+// one of its fields.
+func (p pointer) offset(f field) pointer {
+	return pointer{v: p.v.Elem().FieldByIndex(f).Addr()}
+}
+
+func (p pointer) isNil() bool {
+	return p.v.IsNil()
+}
+
+// grow updates the slice s in place to make it one element longer.
+// s must be addressable.
+// Returns the (addressable) new element.
+func grow(s reflect.Value) reflect.Value {
+	n, m := s.Len(), s.Cap()
+	if n < m {
+		s.SetLen(n + 1)
+	} else {
+		s.Set(reflect.Append(s, reflect.Zero(s.Type().Elem())))
+	}
+	return s.Index(n)
+}
+
+func (p pointer) toInt64() *int64 {
+	return p.v.Interface().(*int64)
+}
+func (p pointer) toInt64Ptr() **int64 {
+	return p.v.Interface().(**int64)
+}
+func (p pointer) toInt64Slice() *[]int64 {
+	return p.v.Interface().(*[]int64)
+}
+
+var int32ptr = reflect.TypeOf((*int32)(nil))
+
+func (p pointer) toInt32() *int32 {
+	return p.v.Convert(int32ptr).Interface().(*int32)
+}
+
+// The toInt32Ptr/Slice methods don't work because of enums.
+// Instead, we must use set/get methods for the int32ptr/slice case.
+/*
+	func (p pointer) toInt32Ptr() **int32 {
+		return p.v.Interface().(**int32)
+}
+	func (p pointer) toInt32Slice() *[]int32 {
+		return p.v.Interface().(*[]int32)
+}
+*/
+func (p pointer) getInt32Ptr() *int32 {
+	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
+		// raw int32 type
+		return p.v.Elem().Interface().(*int32)
+	}
+	// an enum
+	return p.v.Elem().Convert(int32PtrType).Interface().(*int32)
+}
+func (p pointer) setInt32Ptr(v int32) {
+	// Allocate value in a *int32. Possibly convert that to a *enum.
+	// Then assign it to a **int32 or **enum.
+	// Note: we can convert *int32 to *enum, but we can't convert
+	// **int32 to **enum!
+	p.v.Elem().Set(reflect.ValueOf(&v).Convert(p.v.Type().Elem()))
+}
+
+// getInt32Slice copies []int32 from p as a new slice.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) getInt32Slice() []int32 {
+	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
+		// raw int32 type
+		return p.v.Elem().Interface().([]int32)
+	}
+	// an enum
+	// Allocate a []int32, then assign []enum's values into it.
+	// Note: we can't convert []enum to []int32.
+	slice := p.v.Elem()
+	s := make([]int32, slice.Len())
+	for i := 0; i < slice.Len(); i++ {
+		s[i] = int32(slice.Index(i).Int())
+	}
+	return s
+}
+
+// setInt32Slice copies []int32 into p as a new slice.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) setInt32Slice(v []int32) {
+	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
+		// raw int32 type
+		p.v.Elem().Set(reflect.ValueOf(v))
+		return
+	}
+	// an enum
+	// Allocate a []enum, then assign []int32's values into it.
+	// Note: we can't convert []enum to []int32.
+	slice := reflect.MakeSlice(p.v.Type().Elem(), len(v), cap(v))
+	for i, x := range v {
+		slice.Index(i).SetInt(int64(x))
+	}
+	p.v.Elem().Set(slice)
+}
+func (p pointer) appendInt32Slice(v int32) {
+	grow(p.v.Elem()).SetInt(int64(v))
+}
+
+func (p pointer) toUint64() *uint64 {
+	return p.v.Interface().(*uint64)
+}
+func (p pointer) toUint64Ptr() **uint64 {
+	return p.v.Interface().(**uint64)
+}
+func (p pointer) toUint64Slice() *[]uint64 {
+	return p.v.Interface().(*[]uint64)
+}
+func (p pointer) toUint32() *uint32 {
+	return p.v.Interface().(*uint32)
+}
+func (p pointer) toUint32Ptr() **uint32 {
+	return p.v.Interface().(**uint32)
+}
+func (p pointer) toUint32Slice() *[]uint32 {
+	return p.v.Interface().(*[]uint32)
+}
+func (p pointer) toBool() *bool {
+	return p.v.Interface().(*bool)
+}
+func (p pointer) toBoolPtr() **bool {
+	return p.v.Interface().(**bool)
+}
+func (p pointer) toBoolSlice() *[]bool {
+	return p.v.Interface().(*[]bool)
+}
+func (p pointer) toFloat64() *float64 {
+	return p.v.Interface().(*float64)
+}
+func (p pointer) toFloat64Ptr() **float64 {
+	return p.v.Interface().(**float64)
+}
+func (p pointer) toFloat64Slice() *[]float64 {
+	return p.v.Interface().(*[]float64)
+}
+func (p pointer) toFloat32() *float32 {
+	return p.v.Interface().(*float32)
+}
+func (p pointer) toFloat32Ptr() **float32 {
+	return p.v.Interface().(**float32)
+}
+func (p pointer) toFloat32Slice() *[]float32 {
+	return p.v.Interface().(*[]float32)
+}
+func (p pointer) toString() *string {
+	return p.v.Interface().(*string)
+}
+func (p pointer) toStringPtr() **string {
+	return p.v.Interface().(**string)
+}
+func (p pointer) toStringSlice() *[]string {
+	return p.v.Interface().(*[]string)
+}
+func (p pointer) toBytes() *[]byte {
+	return p.v.Interface().(*[]byte)
+}
+func (p pointer) toBytesSlice() *[][]byte {
+	return p.v.Interface().(*[][]byte)
+}
+func (p pointer) toExtensions() *XXX_InternalExtensions {
+	return p.v.Interface().(*XXX_InternalExtensions)
+}
+func (p pointer) toOldExtensions() *map[int32]Extension {
+	return p.v.Interface().(*map[int32]Extension)
+}
+func (p pointer) getPointer() pointer {
+	return pointer{v: p.v.Elem()}
+}
+func (p pointer) setPointer(q pointer) {
+	p.v.Elem().Set(q.v)
+}
+func (p pointer) appendPointer(q pointer) {
+	grow(p.v.Elem()).Set(q.v)
+}
+
+// getPointerSlice copies []*T from p as a new []pointer.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) getPointerSlice() []pointer {
+	if p.v.IsNil() {
+		return nil
+	}
+	n := p.v.Elem().Len()
+	s := make([]pointer, n)
+	for i := 0; i < n; i++ {
+		s[i] = pointer{v: p.v.Elem().Index(i)}
+	}
+	return s
+}
+
+// setPointerSlice copies []pointer into p as a new []*T.
+// This behavior differs from the implementation in pointer_unsafe.go.
+func (p pointer) setPointerSlice(v []pointer) {
+	if v == nil {
+		p.v.Elem().Set(reflect.New(p.v.Elem().Type()).Elem())
+		return
+	}
+	s := reflect.MakeSlice(p.v.Elem().Type(), 0, len(v))
+	for _, p := range v {
+		s = reflect.Append(s, p.v)
+	}
+	p.v.Elem().Set(s)
+}
+
+// getInterfacePointer returns a pointer that points to the
+// interface data of the interface pointed by p.
+func (p pointer) getInterfacePointer() pointer {
+	if p.v.Elem().IsNil() {
+		return pointer{v: p.v.Elem()}
+	}
+	return pointer{v: p.v.Elem().Elem().Elem().Field(0).Addr()} // *interface -> interface -> *struct -> struct
+}
+
+func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
+	// TODO: check that p.v.Type().Elem() == t?
+	return p.v
+}
+
+func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
+	atomicLock.Lock()
+	defer atomicLock.Unlock()
+	return *p
+}
+func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
+	atomicLock.Lock()
+	defer atomicLock.Unlock()
+	*p = v
+}
+func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
+	atomicLock.Lock()
+	defer atomicLock.Unlock()
+	return *p
+}
+func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
+	atomicLock.Lock()
+	defer atomicLock.Unlock()
+	*p = v
+}
+func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
+	atomicLock.Lock()
+	defer atomicLock.Unlock()
+	return *p
+}
+func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
+	atomicLock.Lock()
+	defer atomicLock.Unlock()
+	*p = v
+}
+func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
+	atomicLock.Lock()
+	defer atomicLock.Unlock()
+	return *p
+}
+func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
+	atomicLock.Lock()
+	defer atomicLock.Unlock()
+	*p = v
+}
+
+var atomicLock sync.Mutex
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
new file mode 100644
index 0000000..dbfffe0
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
@@ -0,0 +1,313 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build !purego,!appengine,!js
+
+// This file contains the implementation of the proto field accesses using package unsafe.
+
+package proto
+
+import (
+	"reflect"
+	"sync/atomic"
+	"unsafe"
+)
+
+const unsafeAllowed = true
+
+// A field identifies a field in a struct, accessible from a pointer.
+// In this implementation, a field is identified by its byte offset from the start of the struct.
+type field uintptr
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+	return field(f.Offset)
+}
+
+// invalidField is an invalid field identifier.
+const invalidField = ^field(0)
+
+// zeroField is a noop when calling pointer.offset.
+const zeroField = field(0)
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool {
+	return f != invalidField
+}
+
+// The pointer type below is for the new table-driven encoder/decoder.
+// The implementation here uses unsafe.Pointer to create a generic pointer.
+// In pointer_reflect.go we use reflect instead of unsafe to implement
+// the same (but slower) interface.
+type pointer struct {
+	p unsafe.Pointer
+}
+
+// size of pointer
+var ptrSize = unsafe.Sizeof(uintptr(0))
+
+// toPointer converts an interface of pointer type to a pointer
+// that points to the same target.
+func toPointer(i *Message) pointer {
+	// Super-tricky - read pointer out of data word of interface value.
+	// Saves ~25ns over the equivalent:
+	// return valToPointer(reflect.ValueOf(*i))
+	return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
+}
+
+// toAddrPointer converts an interface to a pointer that points to
+// the interface data.
+func toAddrPointer(i *interface{}, isptr, deref bool) (p pointer) {
+	// Super-tricky - read or get the address of data word of interface value.
+	if isptr {
+		// The interface is of pointer type, thus it is a direct interface.
+		// The data word is the pointer data itself. We take its address.
+		p = pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
+	} else {
+		// The interface is not of pointer type. The data word is the pointer
+		// to the data.
+		p = pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
+	}
+	if deref {
+		p.p = *(*unsafe.Pointer)(p.p)
+	}
+	return p
+}
+
+// valToPointer converts v to a pointer. v must be of pointer type.
+func valToPointer(v reflect.Value) pointer {
+	return pointer{p: unsafe.Pointer(v.Pointer())}
+}
+
+// offset converts from a pointer to a structure to a pointer to
+// one of its fields.
+func (p pointer) offset(f field) pointer {
+	// For safety, we should panic if !f.IsValid, however calling panic causes
+	// this to no longer be inlineable, which is a serious performance cost.
+	/*
+		if !f.IsValid() {
+			panic("invalid field")
+		}
+	*/
+	return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
+}
+
+func (p pointer) isNil() bool {
+	return p.p == nil
+}
+
+func (p pointer) toInt64() *int64 {
+	return (*int64)(p.p)
+}
+func (p pointer) toInt64Ptr() **int64 {
+	return (**int64)(p.p)
+}
+func (p pointer) toInt64Slice() *[]int64 {
+	return (*[]int64)(p.p)
+}
+func (p pointer) toInt32() *int32 {
+	return (*int32)(p.p)
+}
+
+// See pointer_reflect.go for why toInt32Ptr/Slice doesn't exist.
+/*
+	func (p pointer) toInt32Ptr() **int32 {
+		return (**int32)(p.p)
+	}
+	func (p pointer) toInt32Slice() *[]int32 {
+		return (*[]int32)(p.p)
+	}
+*/
+func (p pointer) getInt32Ptr() *int32 {
+	return *(**int32)(p.p)
+}
+func (p pointer) setInt32Ptr(v int32) {
+	*(**int32)(p.p) = &v
+}
+
+// getInt32Slice loads a []int32 from p.
+// The value returned is aliased with the original slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) getInt32Slice() []int32 {
+	return *(*[]int32)(p.p)
+}
+
+// setInt32Slice stores a []int32 to p.
+// The value set is aliased with the input slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) setInt32Slice(v []int32) {
+	*(*[]int32)(p.p) = v
+}
+
+// TODO: Can we get rid of appendInt32Slice and use setInt32Slice instead?
+func (p pointer) appendInt32Slice(v int32) {
+	s := (*[]int32)(p.p)
+	*s = append(*s, v)
+}
+
+func (p pointer) toUint64() *uint64 {
+	return (*uint64)(p.p)
+}
+func (p pointer) toUint64Ptr() **uint64 {
+	return (**uint64)(p.p)
+}
+func (p pointer) toUint64Slice() *[]uint64 {
+	return (*[]uint64)(p.p)
+}
+func (p pointer) toUint32() *uint32 {
+	return (*uint32)(p.p)
+}
+func (p pointer) toUint32Ptr() **uint32 {
+	return (**uint32)(p.p)
+}
+func (p pointer) toUint32Slice() *[]uint32 {
+	return (*[]uint32)(p.p)
+}
+func (p pointer) toBool() *bool {
+	return (*bool)(p.p)
+}
+func (p pointer) toBoolPtr() **bool {
+	return (**bool)(p.p)
+}
+func (p pointer) toBoolSlice() *[]bool {
+	return (*[]bool)(p.p)
+}
+func (p pointer) toFloat64() *float64 {
+	return (*float64)(p.p)
+}
+func (p pointer) toFloat64Ptr() **float64 {
+	return (**float64)(p.p)
+}
+func (p pointer) toFloat64Slice() *[]float64 {
+	return (*[]float64)(p.p)
+}
+func (p pointer) toFloat32() *float32 {
+	return (*float32)(p.p)
+}
+func (p pointer) toFloat32Ptr() **float32 {
+	return (**float32)(p.p)
+}
+func (p pointer) toFloat32Slice() *[]float32 {
+	return (*[]float32)(p.p)
+}
+func (p pointer) toString() *string {
+	return (*string)(p.p)
+}
+func (p pointer) toStringPtr() **string {
+	return (**string)(p.p)
+}
+func (p pointer) toStringSlice() *[]string {
+	return (*[]string)(p.p)
+}
+func (p pointer) toBytes() *[]byte {
+	return (*[]byte)(p.p)
+}
+func (p pointer) toBytesSlice() *[][]byte {
+	return (*[][]byte)(p.p)
+}
+func (p pointer) toExtensions() *XXX_InternalExtensions {
+	return (*XXX_InternalExtensions)(p.p)
+}
+func (p pointer) toOldExtensions() *map[int32]Extension {
+	return (*map[int32]Extension)(p.p)
+}
+
+// getPointerSlice loads []*T from p as a []pointer.
+// The value returned is aliased with the original slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) getPointerSlice() []pointer {
+	// Super-tricky - p should point to a []*T where T is a
+	// message type. We load it as []pointer.
+	return *(*[]pointer)(p.p)
+}
+
+// setPointerSlice stores []pointer into p as a []*T.
+// The value set is aliased with the input slice.
+// This behavior differs from the implementation in pointer_reflect.go.
+func (p pointer) setPointerSlice(v []pointer) {
+	// Super-tricky - p should point to a []*T where T is a
+	// message type. We store it as []pointer.
+	*(*[]pointer)(p.p) = v
+}
+
+// getPointer loads the pointer at p and returns it.
+func (p pointer) getPointer() pointer {
+	return pointer{p: *(*unsafe.Pointer)(p.p)}
+}
+
+// setPointer stores the pointer q at p.
+func (p pointer) setPointer(q pointer) {
+	*(*unsafe.Pointer)(p.p) = q.p
+}
+
+// append q to the slice pointed to by p.
+func (p pointer) appendPointer(q pointer) {
+	s := (*[]unsafe.Pointer)(p.p)
+	*s = append(*s, q.p)
+}
+
+// getInterfacePointer returns a pointer that points to the
+// interface data of the interface pointed by p.
+func (p pointer) getInterfacePointer() pointer {
+	// Super-tricky - read pointer out of data word of interface value.
+	return pointer{p: (*(*[2]unsafe.Pointer)(p.p))[1]}
+}
+
+// asPointerTo returns a reflect.Value that is a pointer to an
+// object of type t stored at p.
+func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
+	return reflect.NewAt(t, p.p)
+}
+
+func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
+	return (*unmarshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
+	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
+func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
+	return (*marshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
+	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
+func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
+	return (*mergeInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
+	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
+func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
+	return (*discardInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
+}
+func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
+	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))
+}
diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go
index dcdc220..a4b8c0c 100644
--- a/vendor/github.com/golang/protobuf/proto/properties.go
+++ b/vendor/github.com/golang/protobuf/proto/properties.go
@@ -1,104 +1,162 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 package proto
 
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
 import (
 	"fmt"
+	"log"
 	"reflect"
+	"sort"
 	"strconv"
 	"strings"
 	"sync"
-
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoimpl"
 )
 
-// StructProperties represents protocol buffer type information for a
-// generated protobuf message in the open-struct API.
-//
-// Deprecated: Do not use.
+const debug bool = false
+
+// Constants that identify the encoding of a value on the wire.
+const (
+	WireVarint     = 0
+	WireFixed64    = 1
+	WireBytes      = 2
+	WireStartGroup = 3
+	WireEndGroup   = 4
+	WireFixed32    = 5
+)
+
+// tagMap is an optimization over map[int]int for typical protocol buffer
+// use-cases. Encoded protocol buffers are often in tag order with small tag
+// numbers.
+type tagMap struct {
+	fastTags []int
+	slowTags map[int]int
+}
+
+// tagMapFastLimit is the upper bound on the tag number that will be stored in
+// the tagMap slice rather than its map.
+const tagMapFastLimit = 1024
+
+func (p *tagMap) get(t int) (int, bool) {
+	if t > 0 && t < tagMapFastLimit {
+		if t >= len(p.fastTags) {
+			return 0, false
+		}
+		fi := p.fastTags[t]
+		return fi, fi >= 0
+	}
+	fi, ok := p.slowTags[t]
+	return fi, ok
+}
+
+func (p *tagMap) put(t int, fi int) {
+	if t > 0 && t < tagMapFastLimit {
+		for len(p.fastTags) < t+1 {
+			p.fastTags = append(p.fastTags, -1)
+		}
+		p.fastTags[t] = fi
+		return
+	}
+	if p.slowTags == nil {
+		p.slowTags = make(map[int]int)
+	}
+	p.slowTags[t] = fi
+}
+
+// StructProperties represents properties for all the fields of a struct.
+// decoderTags and decoderOrigNames should only be used by the decoder.
 type StructProperties struct {
-	// Prop are the properties for each field.
-	//
-	// Fields belonging to a oneof are stored in OneofTypes instead, with a
-	// single Properties representing the parent oneof held here.
-	//
-	// The order of Prop matches the order of fields in the Go struct.
-	// Struct fields that are not related to protobufs have a "XXX_" prefix
-	// in the Properties.Name and must be ignored by the user.
-	Prop []*Properties
+	Prop             []*Properties  // properties for each field
+	reqCount         int            // required count
+	decoderTags      tagMap         // map from proto tag to struct field number
+	decoderOrigNames map[string]int // map from original name to struct field number
+	order            []int          // list of struct field numbers in tag order
 
 	// OneofTypes contains information about the oneof fields in this message.
-	// It is keyed by the protobuf field name.
+	// It is keyed by the original name of a field.
 	OneofTypes map[string]*OneofProperties
 }
 
-// Properties represents the type information for a protobuf message field.
-//
-// Deprecated: Do not use.
-type Properties struct {
-	// Name is a placeholder name with little meaningful semantic value.
-	// If the name has an "XXX_" prefix, the entire Properties must be ignored.
-	Name string
-	// OrigName is the protobuf field name or oneof name.
-	OrigName string
-	// JSONName is the JSON name for the protobuf field.
-	JSONName string
-	// Enum is a placeholder name for enums.
-	// For historical reasons, this is neither the Go name for the enum,
-	// nor the protobuf name for the enum.
-	Enum string // Deprecated: Do not use.
-	// Weak contains the full name of the weakly referenced message.
-	Weak string
-	// Wire is a string representation of the wire type.
-	Wire string
-	// WireType is the protobuf wire type for the field.
-	WireType int
-	// Tag is the protobuf field number.
-	Tag int
-	// Required reports whether this is a required field.
-	Required bool
-	// Optional reports whether this is a optional field.
-	Optional bool
-	// Repeated reports whether this is a repeated field.
-	Repeated bool
-	// Packed reports whether this is a packed repeated field of scalars.
-	Packed bool
-	// Proto3 reports whether this field operates under the proto3 syntax.
-	Proto3 bool
-	// Oneof reports whether this field belongs within a oneof.
-	Oneof bool
-
-	// Default is the default value in string form.
-	Default string
-	// HasDefault reports whether the field has a default value.
-	HasDefault bool
-
-	// MapKeyProp is the properties for the key field for a map field.
-	MapKeyProp *Properties
-	// MapValProp is the properties for the value field for a map field.
-	MapValProp *Properties
+// OneofProperties represents information about a specific field in a oneof.
+type OneofProperties struct {
+	Type  reflect.Type // pointer to generated struct type for this oneof field
+	Field int          // struct field number of the containing oneof in the message
+	Prop  *Properties
 }
 
-// OneofProperties represents the type information for a protobuf oneof.
-//
-// Deprecated: Do not use.
-type OneofProperties struct {
-	// Type is a pointer to the generated wrapper type for the field value.
-	// This is nil for messages that are not in the open-struct API.
-	Type reflect.Type
-	// Field is the index into StructProperties.Prop for the containing oneof.
-	Field int
-	// Prop is the properties for the field.
-	Prop *Properties
+// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
+// See encode.go, (*Buffer).enc_struct.
+
+func (sp *StructProperties) Len() int { return len(sp.order) }
+func (sp *StructProperties) Less(i, j int) bool {
+	return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
+}
+func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
+
+// Properties represents the protocol-specific behavior of a single struct field.
+type Properties struct {
+	Name     string // name of the field, for error messages
+	OrigName string // original name before protocol compiler (always set)
+	JSONName string // name to use for JSON; determined by protoc
+	Wire     string
+	WireType int
+	Tag      int
+	Required bool
+	Optional bool
+	Repeated bool
+	Packed   bool   // relevant for repeated primitives only
+	Enum     string // set for enum types only
+	proto3   bool   // whether this is known to be a proto3 field
+	oneof    bool   // whether this is a oneof field
+
+	Default    string // default value
+	HasDefault bool   // whether an explicit default was provided
+
+	stype reflect.Type      // set for struct types only
+	sprop *StructProperties // set for struct types only
+
+	mtype      reflect.Type // set for map types only
+	MapKeyProp *Properties  // set for map types only
+	MapValProp *Properties  // set for map types only
 }
 
 // String formats the properties in the protobuf struct field tag style.
 func (p *Properties) String() string {
 	s := p.Wire
-	s += "," + strconv.Itoa(p.Tag)
+	s += ","
+	s += strconv.Itoa(p.Tag)
 	if p.Required {
 		s += ",req"
 	}
@@ -112,21 +170,18 @@
 		s += ",packed"
 	}
 	s += ",name=" + p.OrigName
-	if p.JSONName != "" {
+	if p.JSONName != p.OrigName {
 		s += ",json=" + p.JSONName
 	}
+	if p.proto3 {
+		s += ",proto3"
+	}
+	if p.oneof {
+		s += ",oneof"
+	}
 	if len(p.Enum) > 0 {
 		s += ",enum=" + p.Enum
 	}
-	if len(p.Weak) > 0 {
-		s += ",weak=" + p.Weak
-	}
-	if p.Proto3 {
-		s += ",proto3"
-	}
-	if p.Oneof {
-		s += ",oneof"
-	}
 	if p.HasDefault {
 		s += ",def=" + p.Default
 	}
@@ -134,173 +189,356 @@
 }
 
 // Parse populates p by parsing a string in the protobuf struct field tag style.
-func (p *Properties) Parse(tag string) {
-	// For example: "bytes,49,opt,name=foo,def=hello!"
-	for len(tag) > 0 {
-		i := strings.IndexByte(tag, ',')
-		if i < 0 {
-			i = len(tag)
-		}
-		switch s := tag[:i]; {
-		case strings.HasPrefix(s, "name="):
-			p.OrigName = s[len("name="):]
-		case strings.HasPrefix(s, "json="):
-			p.JSONName = s[len("json="):]
-		case strings.HasPrefix(s, "enum="):
-			p.Enum = s[len("enum="):]
-		case strings.HasPrefix(s, "weak="):
-			p.Weak = s[len("weak="):]
-		case strings.Trim(s, "0123456789") == "":
-			n, _ := strconv.ParseUint(s, 10, 32)
-			p.Tag = int(n)
-		case s == "opt":
-			p.Optional = true
-		case s == "req":
+func (p *Properties) Parse(s string) {
+	// "bytes,49,opt,name=foo,def=hello!"
+	fields := strings.Split(s, ",") // breaks def=, but handled below.
+	if len(fields) < 2 {
+		log.Printf("proto: tag has too few fields: %q", s)
+		return
+	}
+
+	p.Wire = fields[0]
+	switch p.Wire {
+	case "varint":
+		p.WireType = WireVarint
+	case "fixed32":
+		p.WireType = WireFixed32
+	case "fixed64":
+		p.WireType = WireFixed64
+	case "zigzag32":
+		p.WireType = WireVarint
+	case "zigzag64":
+		p.WireType = WireVarint
+	case "bytes", "group":
+		p.WireType = WireBytes
+		// no numeric converter for non-numeric types
+	default:
+		log.Printf("proto: tag has unknown wire type: %q", s)
+		return
+	}
+
+	var err error
+	p.Tag, err = strconv.Atoi(fields[1])
+	if err != nil {
+		return
+	}
+
+outer:
+	for i := 2; i < len(fields); i++ {
+		f := fields[i]
+		switch {
+		case f == "req":
 			p.Required = true
-		case s == "rep":
+		case f == "opt":
+			p.Optional = true
+		case f == "rep":
 			p.Repeated = true
-		case s == "varint" || s == "zigzag32" || s == "zigzag64":
-			p.Wire = s
-			p.WireType = WireVarint
-		case s == "fixed32":
-			p.Wire = s
-			p.WireType = WireFixed32
-		case s == "fixed64":
-			p.Wire = s
-			p.WireType = WireFixed64
-		case s == "bytes":
-			p.Wire = s
-			p.WireType = WireBytes
-		case s == "group":
-			p.Wire = s
-			p.WireType = WireStartGroup
-		case s == "packed":
+		case f == "packed":
 			p.Packed = true
-		case s == "proto3":
-			p.Proto3 = true
-		case s == "oneof":
-			p.Oneof = true
-		case strings.HasPrefix(s, "def="):
-			// The default tag is special in that everything afterwards is the
-			// default regardless of the presence of commas.
+		case strings.HasPrefix(f, "name="):
+			p.OrigName = f[5:]
+		case strings.HasPrefix(f, "json="):
+			p.JSONName = f[5:]
+		case strings.HasPrefix(f, "enum="):
+			p.Enum = f[5:]
+		case f == "proto3":
+			p.proto3 = true
+		case f == "oneof":
+			p.oneof = true
+		case strings.HasPrefix(f, "def="):
 			p.HasDefault = true
-			p.Default, i = tag[len("def="):], len(tag)
+			p.Default = f[4:] // rest of string
+			if i+1 < len(fields) {
+				// Commas aren't escaped, and def is always last.
+				p.Default += "," + strings.Join(fields[i+1:], ",")
+				break outer
+			}
 		}
-		tag = strings.TrimPrefix(tag[i:], ",")
 	}
 }
 
+var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
+
+// setFieldProps initializes the field properties for submessages and maps.
+func (p *Properties) setFieldProps(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
+	switch t1 := typ; t1.Kind() {
+	case reflect.Ptr:
+		if t1.Elem().Kind() == reflect.Struct {
+			p.stype = t1.Elem()
+		}
+
+	case reflect.Slice:
+		if t2 := t1.Elem(); t2.Kind() == reflect.Ptr && t2.Elem().Kind() == reflect.Struct {
+			p.stype = t2.Elem()
+		}
+
+	case reflect.Map:
+		p.mtype = t1
+		p.MapKeyProp = &Properties{}
+		p.MapKeyProp.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
+		p.MapValProp = &Properties{}
+		vtype := p.mtype.Elem()
+		if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
+			// The value type is not a message (*T) or bytes ([]byte),
+			// so we need encoders for the pointer to this type.
+			vtype = reflect.PtrTo(vtype)
+		}
+		p.MapValProp.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
+	}
+
+	if p.stype != nil {
+		if lockGetProp {
+			p.sprop = GetProperties(p.stype)
+		} else {
+			p.sprop = getPropertiesLocked(p.stype)
+		}
+	}
+}
+
+var (
+	marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
+)
+
 // Init populates the properties from a protocol buffer struct tag.
-//
-// Deprecated: Do not use.
 func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
+	p.init(typ, name, tag, f, true)
+}
+
+func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
+	// "bytes,49,opt,def=hello!"
 	p.Name = name
 	p.OrigName = name
 	if tag == "" {
 		return
 	}
 	p.Parse(tag)
-
-	if typ != nil && typ.Kind() == reflect.Map {
-		p.MapKeyProp = new(Properties)
-		p.MapKeyProp.Init(nil, "Key", f.Tag.Get("protobuf_key"), nil)
-		p.MapValProp = new(Properties)
-		p.MapValProp.Init(nil, "Value", f.Tag.Get("protobuf_val"), nil)
-	}
+	p.setFieldProps(typ, f, lockGetProp)
 }
 
-var propertiesCache sync.Map // map[reflect.Type]*StructProperties
+var (
+	propertiesMu  sync.RWMutex
+	propertiesMap = make(map[reflect.Type]*StructProperties)
+)
 
-// GetProperties returns the list of properties for the type represented by t,
-// which must be a generated protocol buffer message in the open-struct API,
-// where protobuf message fields are represented by exported Go struct fields.
-//
-// Deprecated: Use protobuf reflection instead.
+// GetProperties returns the list of properties for the type represented by t.
+// t must represent a generated struct type of a protocol message.
 func GetProperties(t reflect.Type) *StructProperties {
-	if p, ok := propertiesCache.Load(t); ok {
-		return p.(*StructProperties)
+	if t.Kind() != reflect.Struct {
+		panic("proto: type must have kind struct")
 	}
-	p, _ := propertiesCache.LoadOrStore(t, newProperties(t))
-	return p.(*StructProperties)
+
+	// Most calls to GetProperties in a long-running program will be
+	// retrieving details for types we have seen before.
+	propertiesMu.RLock()
+	sprop, ok := propertiesMap[t]
+	propertiesMu.RUnlock()
+	if ok {
+		return sprop
+	}
+
+	propertiesMu.Lock()
+	sprop = getPropertiesLocked(t)
+	propertiesMu.Unlock()
+	return sprop
 }
 
-func newProperties(t reflect.Type) *StructProperties {
-	if t.Kind() != reflect.Struct {
-		panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
+type (
+	oneofFuncsIface interface {
+		XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
+	}
+	oneofWrappersIface interface {
+		XXX_OneofWrappers() []interface{}
+	}
+)
+
+// getPropertiesLocked requires that propertiesMu is held.
+func getPropertiesLocked(t reflect.Type) *StructProperties {
+	if prop, ok := propertiesMap[t]; ok {
+		return prop
 	}
 
-	var hasOneof bool
 	prop := new(StructProperties)
+	// in case of recursive protos, fill this in now.
+	propertiesMap[t] = prop
 
-	// Construct a list of properties for each field in the struct.
+	// build properties
+	prop.Prop = make([]*Properties, t.NumField())
+	prop.order = make([]int, t.NumField())
+
 	for i := 0; i < t.NumField(); i++ {
-		p := new(Properties)
 		f := t.Field(i)
-		tagField := f.Tag.Get("protobuf")
-		p.Init(f.Type, f.Name, tagField, &f)
+		p := new(Properties)
+		name := f.Name
+		p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
 
-		tagOneof := f.Tag.Get("protobuf_oneof")
-		if tagOneof != "" {
-			hasOneof = true
-			p.OrigName = tagOneof
+		oneof := f.Tag.Get("protobuf_oneof") // special case
+		if oneof != "" {
+			// Oneof fields don't use the traditional protobuf tag.
+			p.OrigName = oneof
 		}
-
-		// Rename unrelated struct fields with the "XXX_" prefix since so much
-		// user code simply checks for this to exclude special fields.
-		if tagField == "" && tagOneof == "" && !strings.HasPrefix(p.Name, "XXX_") {
-			p.Name = "XXX_" + p.Name
-			p.OrigName = "XXX_" + p.OrigName
-		} else if p.Weak != "" {
-			p.Name = p.OrigName // avoid possible "XXX_" prefix on weak field
+		prop.Prop[i] = p
+		prop.order[i] = i
+		if debug {
+			print(i, " ", f.Name, " ", t.String(), " ")
+			if p.Tag > 0 {
+				print(p.String())
+			}
+			print("\n")
 		}
-
-		prop.Prop = append(prop.Prop, p)
 	}
 
-	// Construct a mapping of oneof field names to properties.
-	if hasOneof {
-		var oneofWrappers []interface{}
-		if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofFuncs"); ok {
-			oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3].Interface().([]interface{})
-		}
-		if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofWrappers"); ok {
-			oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0].Interface().([]interface{})
-		}
-		if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(protoreflect.ProtoMessage); ok {
-			if m, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *protoimpl.MessageInfo }); ok {
-				oneofWrappers = m.ProtoMessageInfo().OneofWrappers
-			}
-		}
+	// Re-order prop.order.
+	sort.Sort(prop)
 
+	var oots []interface{}
+	switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
+	case oneofFuncsIface:
+		_, _, _, oots = m.XXX_OneofFuncs()
+	case oneofWrappersIface:
+		oots = m.XXX_OneofWrappers()
+	}
+	if len(oots) > 0 {
+		// Interpret oneof metadata.
 		prop.OneofTypes = make(map[string]*OneofProperties)
-		for _, wrapper := range oneofWrappers {
-			p := &OneofProperties{
-				Type: reflect.ValueOf(wrapper).Type(), // *T
+		for _, oot := range oots {
+			oop := &OneofProperties{
+				Type: reflect.ValueOf(oot).Type(), // *T
 				Prop: new(Properties),
 			}
-			f := p.Type.Elem().Field(0)
-			p.Prop.Name = f.Name
-			p.Prop.Parse(f.Tag.Get("protobuf"))
-
-			// Determine the struct field that contains this oneof.
-			// Each wrapper is assignable to exactly one parent field.
-			var foundOneof bool
-			for i := 0; i < t.NumField() && !foundOneof; i++ {
-				if p.Type.AssignableTo(t.Field(i).Type) {
-					p.Field = i
-					foundOneof = true
+			sft := oop.Type.Elem().Field(0)
+			oop.Prop.Name = sft.Name
+			oop.Prop.Parse(sft.Tag.Get("protobuf"))
+			// There will be exactly one interface field that
+			// this new value is assignable to.
+			for i := 0; i < t.NumField(); i++ {
+				f := t.Field(i)
+				if f.Type.Kind() != reflect.Interface {
+					continue
 				}
+				if !oop.Type.AssignableTo(f.Type) {
+					continue
+				}
+				oop.Field = i
+				break
 			}
-			if !foundOneof {
-				panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
-			}
-			prop.OneofTypes[p.Prop.OrigName] = p
+			prop.OneofTypes[oop.Prop.OrigName] = oop
 		}
 	}
 
+	// build required counts
+	// build tags
+	reqCount := 0
+	prop.decoderOrigNames = make(map[string]int)
+	for i, p := range prop.Prop {
+		if strings.HasPrefix(p.Name, "XXX_") {
+			// Internal fields should not appear in tags/origNames maps.
+			// They are handled specially when encoding and decoding.
+			continue
+		}
+		if p.Required {
+			reqCount++
+		}
+		prop.decoderTags.put(p.Tag, i)
+		prop.decoderOrigNames[p.OrigName] = i
+	}
+	prop.reqCount = reqCount
+
 	return prop
 }
 
-func (sp *StructProperties) Len() int           { return len(sp.Prop) }
-func (sp *StructProperties) Less(i, j int) bool { return false }
-func (sp *StructProperties) Swap(i, j int)      { return }
+// A global registry of enum types.
+// The generated code will register the generated maps by calling RegisterEnum.
+
+var enumValueMaps = make(map[string]map[string]int32)
+
+// RegisterEnum is called from the generated code to install the enum descriptor
+// maps into the global table to aid parsing text format protocol buffers.
+func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
+	if _, ok := enumValueMaps[typeName]; ok {
+		panic("proto: duplicate enum registered: " + typeName)
+	}
+	enumValueMaps[typeName] = valueMap
+}
+
+// EnumValueMap returns the mapping from names to integers of the
+// enum type enumType, or a nil if not found.
+func EnumValueMap(enumType string) map[string]int32 {
+	return enumValueMaps[enumType]
+}
+
+// A registry of all linked message types.
+// The string is a fully-qualified proto name ("pkg.Message").
+var (
+	protoTypedNils = make(map[string]Message)      // a map from proto names to typed nil pointers
+	protoMapTypes  = make(map[string]reflect.Type) // a map from proto names to map types
+	revProtoTypes  = make(map[reflect.Type]string)
+)
+
+// RegisterType is called from generated code and maps from the fully qualified
+// proto name to the type (pointer to struct) of the protocol buffer.
+func RegisterType(x Message, name string) {
+	if _, ok := protoTypedNils[name]; ok {
+		// TODO: Some day, make this a panic.
+		log.Printf("proto: duplicate proto type registered: %s", name)
+		return
+	}
+	t := reflect.TypeOf(x)
+	if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 {
+		// Generated code always calls RegisterType with nil x.
+		// This check is just for extra safety.
+		protoTypedNils[name] = x
+	} else {
+		protoTypedNils[name] = reflect.Zero(t).Interface().(Message)
+	}
+	revProtoTypes[t] = name
+}
+
+// RegisterMapType is called from generated code and maps from the fully qualified
+// proto name to the native map type of the proto map definition.
+func RegisterMapType(x interface{}, name string) {
+	if reflect.TypeOf(x).Kind() != reflect.Map {
+		panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name))
+	}
+	if _, ok := protoMapTypes[name]; ok {
+		log.Printf("proto: duplicate proto type registered: %s", name)
+		return
+	}
+	t := reflect.TypeOf(x)
+	protoMapTypes[name] = t
+	revProtoTypes[t] = name
+}
+
+// MessageName returns the fully-qualified proto name for the given message type.
+func MessageName(x Message) string {
+	type xname interface {
+		XXX_MessageName() string
+	}
+	if m, ok := x.(xname); ok {
+		return m.XXX_MessageName()
+	}
+	return revProtoTypes[reflect.TypeOf(x)]
+}
+
+// MessageType returns the message type (pointer to struct) for a named message.
+// The type is not guaranteed to implement proto.Message if the name refers to a
+// map entry.
+func MessageType(name string) reflect.Type {
+	if t, ok := protoTypedNils[name]; ok {
+		return reflect.TypeOf(t)
+	}
+	return protoMapTypes[name]
+}
+
+// A registry of all linked proto files.
+var (
+	protoFiles = make(map[string][]byte) // file name => fileDescriptor
+)
+
+// RegisterFile is called from generated code and maps from the
+// full file name of a .proto file to its compressed FileDescriptorProto.
+func RegisterFile(filename string, fileDescriptor []byte) {
+	protoFiles[filename] = fileDescriptor
+}
+
+// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
+func FileDescriptor(filename string) []byte { return protoFiles[filename] }
diff --git a/vendor/github.com/golang/protobuf/proto/proto.go b/vendor/github.com/golang/protobuf/proto/proto.go
deleted file mode 100644
index 5aee89c..0000000
--- a/vendor/github.com/golang/protobuf/proto/proto.go
+++ /dev/null
@@ -1,167 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package proto provides functionality for handling protocol buffer messages.
-// In particular, it provides marshaling and unmarshaling between a protobuf
-// message and the binary wire format.
-//
-// See https://developers.google.com/protocol-buffers/docs/gotutorial for
-// more information.
-//
-// Deprecated: Use the "google.golang.org/protobuf/proto" package instead.
-package proto
-
-import (
-	protoV2 "google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoiface"
-	"google.golang.org/protobuf/runtime/protoimpl"
-)
-
-const (
-	ProtoPackageIsVersion1 = true
-	ProtoPackageIsVersion2 = true
-	ProtoPackageIsVersion3 = true
-	ProtoPackageIsVersion4 = true
-)
-
-// GeneratedEnum is any enum type generated by protoc-gen-go
-// which is a named int32 kind.
-// This type exists for documentation purposes.
-type GeneratedEnum interface{}
-
-// GeneratedMessage is any message type generated by protoc-gen-go
-// which is a pointer to a named struct kind.
-// This type exists for documentation purposes.
-type GeneratedMessage interface{}
-
-// Message is a protocol buffer message.
-//
-// This is the v1 version of the message interface and is marginally better
-// than an empty interface as it lacks any method to programatically interact
-// with the contents of the message.
-//
-// A v2 message is declared in "google.golang.org/protobuf/proto".Message and
-// exposes protobuf reflection as a first-class feature of the interface.
-//
-// To convert a v1 message to a v2 message, use the MessageV2 function.
-// To convert a v2 message to a v1 message, use the MessageV1 function.
-type Message = protoiface.MessageV1
-
-// MessageV1 converts either a v1 or v2 message to a v1 message.
-// It returns nil if m is nil.
-func MessageV1(m GeneratedMessage) protoiface.MessageV1 {
-	return protoimpl.X.ProtoMessageV1Of(m)
-}
-
-// MessageV2 converts either a v1 or v2 message to a v2 message.
-// It returns nil if m is nil.
-func MessageV2(m GeneratedMessage) protoV2.Message {
-	return protoimpl.X.ProtoMessageV2Of(m)
-}
-
-// MessageReflect returns a reflective view for a message.
-// It returns nil if m is nil.
-func MessageReflect(m Message) protoreflect.Message {
-	return protoimpl.X.MessageOf(m)
-}
-
-// Marshaler is implemented by messages that can marshal themselves.
-// This interface is used by the following functions: Size, Marshal,
-// Buffer.Marshal, and Buffer.EncodeMessage.
-//
-// Deprecated: Do not implement.
-type Marshaler interface {
-	// Marshal formats the encoded bytes of the message.
-	// It should be deterministic and emit valid protobuf wire data.
-	// The caller takes ownership of the returned buffer.
-	Marshal() ([]byte, error)
-}
-
-// Unmarshaler is implemented by messages that can unmarshal themselves.
-// This interface is used by the following functions: Unmarshal, UnmarshalMerge,
-// Buffer.Unmarshal, Buffer.DecodeMessage, and Buffer.DecodeGroup.
-//
-// Deprecated: Do not implement.
-type Unmarshaler interface {
-	// Unmarshal parses the encoded bytes of the protobuf wire input.
-	// The provided buffer is only valid for during method call.
-	// It should not reset the receiver message.
-	Unmarshal([]byte) error
-}
-
-// Merger is implemented by messages that can merge themselves.
-// This interface is used by the following functions: Clone and Merge.
-//
-// Deprecated: Do not implement.
-type Merger interface {
-	// Merge merges the contents of src into the receiver message.
-	// It clones all data structures in src such that it aliases no mutable
-	// memory referenced by src.
-	Merge(src Message)
-}
-
-// RequiredNotSetError is an error type returned when
-// marshaling or unmarshaling a message with missing required fields.
-type RequiredNotSetError struct {
-	err error
-}
-
-func (e *RequiredNotSetError) Error() string {
-	if e.err != nil {
-		return e.err.Error()
-	}
-	return "proto: required field not set"
-}
-func (e *RequiredNotSetError) RequiredNotSet() bool {
-	return true
-}
-
-func checkRequiredNotSet(m protoV2.Message) error {
-	if err := protoV2.CheckInitialized(m); err != nil {
-		return &RequiredNotSetError{err: err}
-	}
-	return nil
-}
-
-// Clone returns a deep copy of src.
-func Clone(src Message) Message {
-	return MessageV1(protoV2.Clone(MessageV2(src)))
-}
-
-// Merge merges src into dst, which must be messages of the same type.
-//
-// Populated scalar fields in src are copied to dst, while populated
-// singular messages in src are merged into dst by recursively calling Merge.
-// The elements of every list field in src is appended to the corresponded
-// list fields in dst. The entries of every map field in src is copied into
-// the corresponding map field in dst, possibly replacing existing entries.
-// The unknown fields of src are appended to the unknown fields of dst.
-func Merge(dst, src Message) {
-	protoV2.Merge(MessageV2(dst), MessageV2(src))
-}
-
-// Equal reports whether two messages are equal.
-// If two messages marshal to the same bytes under deterministic serialization,
-// then Equal is guaranteed to report true.
-//
-// Two messages are equal if they are the same protobuf message type,
-// have the same set of populated known and extension field values,
-// and the same set of unknown fields values.
-//
-// Scalar values are compared with the equivalent of the == operator in Go,
-// except bytes values which are compared using bytes.Equal and
-// floating point values which specially treat NaNs as equal.
-// Message values are compared by recursively calling Equal.
-// Lists are equal if each element value is also equal.
-// Maps are equal if they have the same set of keys, where the pair of values
-// for each key is also equal.
-func Equal(x, y Message) bool {
-	return protoV2.Equal(MessageV2(x), MessageV2(y))
-}
-
-func isMessageSet(md protoreflect.MessageDescriptor) bool {
-	ms, ok := md.(interface{ IsMessageSet() bool })
-	return ok && ms.IsMessageSet()
-}
diff --git a/vendor/github.com/golang/protobuf/proto/registry.go b/vendor/github.com/golang/protobuf/proto/registry.go
deleted file mode 100644
index 1e7ff64..0000000
--- a/vendor/github.com/golang/protobuf/proto/registry.go
+++ /dev/null
@@ -1,323 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"bytes"
-	"compress/gzip"
-	"fmt"
-	"io/ioutil"
-	"reflect"
-	"strings"
-	"sync"
-
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-	"google.golang.org/protobuf/runtime/protoimpl"
-)
-
-// filePath is the path to the proto source file.
-type filePath = string // e.g., "google/protobuf/descriptor.proto"
-
-// fileDescGZIP is the compressed contents of the encoded FileDescriptorProto.
-type fileDescGZIP = []byte
-
-var fileCache sync.Map // map[filePath]fileDescGZIP
-
-// RegisterFile is called from generated code to register the compressed
-// FileDescriptorProto with the file path for a proto source file.
-//
-// Deprecated: Use protoregistry.GlobalFiles.RegisterFile instead.
-func RegisterFile(s filePath, d fileDescGZIP) {
-	// Decompress the descriptor.
-	zr, err := gzip.NewReader(bytes.NewReader(d))
-	if err != nil {
-		panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
-	}
-	b, err := ioutil.ReadAll(zr)
-	if err != nil {
-		panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
-	}
-
-	// Construct a protoreflect.FileDescriptor from the raw descriptor.
-	// Note that DescBuilder.Build automatically registers the constructed
-	// file descriptor with the v2 registry.
-	protoimpl.DescBuilder{RawDescriptor: b}.Build()
-
-	// Locally cache the raw descriptor form for the file.
-	fileCache.Store(s, d)
-}
-
-// FileDescriptor returns the compressed FileDescriptorProto given the file path
-// for a proto source file. It returns nil if not found.
-//
-// Deprecated: Use protoregistry.GlobalFiles.FindFileByPath instead.
-func FileDescriptor(s filePath) fileDescGZIP {
-	if v, ok := fileCache.Load(s); ok {
-		return v.(fileDescGZIP)
-	}
-
-	// Find the descriptor in the v2 registry.
-	var b []byte
-	if fd, _ := protoregistry.GlobalFiles.FindFileByPath(s); fd != nil {
-		if fd, ok := fd.(interface{ ProtoLegacyRawDesc() []byte }); ok {
-			b = fd.ProtoLegacyRawDesc()
-		} else {
-			// TODO: Use protodesc.ToFileDescriptorProto to construct
-			// a descriptorpb.FileDescriptorProto and marshal it.
-			// However, doing so causes the proto package to have a dependency
-			// on descriptorpb, leading to cyclic dependency issues.
-		}
-	}
-
-	// Locally cache the raw descriptor form for the file.
-	if len(b) > 0 {
-		v, _ := fileCache.LoadOrStore(s, protoimpl.X.CompressGZIP(b))
-		return v.(fileDescGZIP)
-	}
-	return nil
-}
-
-// enumName is the name of an enum. For historical reasons, the enum name is
-// neither the full Go name nor the full protobuf name of the enum.
-// The name is the dot-separated combination of just the proto package that the
-// enum is declared within followed by the Go type name of the generated enum.
-type enumName = string // e.g., "my.proto.package.GoMessage_GoEnum"
-
-// enumsByName maps enum values by name to their numeric counterpart.
-type enumsByName = map[string]int32
-
-// enumsByNumber maps enum values by number to their name counterpart.
-type enumsByNumber = map[int32]string
-
-var enumCache sync.Map     // map[enumName]enumsByName
-var numFilesCache sync.Map // map[protoreflect.FullName]int
-
-// RegisterEnum is called from the generated code to register the mapping of
-// enum value names to enum numbers for the enum identified by s.
-//
-// Deprecated: Use protoregistry.GlobalTypes.RegisterEnum instead.
-func RegisterEnum(s enumName, _ enumsByNumber, m enumsByName) {
-	if _, ok := enumCache.Load(s); ok {
-		panic("proto: duplicate enum registered: " + s)
-	}
-	enumCache.Store(s, m)
-
-	// This does not forward registration to the v2 registry since this API
-	// lacks sufficient information to construct a complete v2 enum descriptor.
-}
-
-// EnumValueMap returns the mapping from enum value names to enum numbers for
-// the enum of the given name. It returns nil if not found.
-//
-// Deprecated: Use protoregistry.GlobalTypes.FindEnumByName instead.
-func EnumValueMap(s enumName) enumsByName {
-	if v, ok := enumCache.Load(s); ok {
-		return v.(enumsByName)
-	}
-
-	// Check whether the cache is stale. If the number of files in the current
-	// package differs, then it means that some enums may have been recently
-	// registered upstream that we do not know about.
-	var protoPkg protoreflect.FullName
-	if i := strings.LastIndexByte(s, '.'); i >= 0 {
-		protoPkg = protoreflect.FullName(s[:i])
-	}
-	v, _ := numFilesCache.Load(protoPkg)
-	numFiles, _ := v.(int)
-	if protoregistry.GlobalFiles.NumFilesByPackage(protoPkg) == numFiles {
-		return nil // cache is up-to-date; was not found earlier
-	}
-
-	// Update the enum cache for all enums declared in the given proto package.
-	numFiles = 0
-	protoregistry.GlobalFiles.RangeFilesByPackage(protoPkg, func(fd protoreflect.FileDescriptor) bool {
-		walkEnums(fd, func(ed protoreflect.EnumDescriptor) {
-			name := protoimpl.X.LegacyEnumName(ed)
-			if _, ok := enumCache.Load(name); !ok {
-				m := make(enumsByName)
-				evs := ed.Values()
-				for i := evs.Len() - 1; i >= 0; i-- {
-					ev := evs.Get(i)
-					m[string(ev.Name())] = int32(ev.Number())
-				}
-				enumCache.LoadOrStore(name, m)
-			}
-		})
-		numFiles++
-		return true
-	})
-	numFilesCache.Store(protoPkg, numFiles)
-
-	// Check cache again for enum map.
-	if v, ok := enumCache.Load(s); ok {
-		return v.(enumsByName)
-	}
-	return nil
-}
-
-// walkEnums recursively walks all enums declared in d.
-func walkEnums(d interface {
-	Enums() protoreflect.EnumDescriptors
-	Messages() protoreflect.MessageDescriptors
-}, f func(protoreflect.EnumDescriptor)) {
-	eds := d.Enums()
-	for i := eds.Len() - 1; i >= 0; i-- {
-		f(eds.Get(i))
-	}
-	mds := d.Messages()
-	for i := mds.Len() - 1; i >= 0; i-- {
-		walkEnums(mds.Get(i), f)
-	}
-}
-
-// messageName is the full name of protobuf message.
-type messageName = string
-
-var messageTypeCache sync.Map // map[messageName]reflect.Type
-
-// RegisterType is called from generated code to register the message Go type
-// for a message of the given name.
-//
-// Deprecated: Use protoregistry.GlobalTypes.RegisterMessage instead.
-func RegisterType(m Message, s messageName) {
-	mt := protoimpl.X.LegacyMessageTypeOf(m, protoreflect.FullName(s))
-	if err := protoregistry.GlobalTypes.RegisterMessage(mt); err != nil {
-		panic(err)
-	}
-	messageTypeCache.Store(s, reflect.TypeOf(m))
-}
-
-// RegisterMapType is called from generated code to register the Go map type
-// for a protobuf message representing a map entry.
-//
-// Deprecated: Do not use.
-func RegisterMapType(m interface{}, s messageName) {
-	t := reflect.TypeOf(m)
-	if t.Kind() != reflect.Map {
-		panic(fmt.Sprintf("invalid map kind: %v", t))
-	}
-	if _, ok := messageTypeCache.Load(s); ok {
-		panic(fmt.Errorf("proto: duplicate proto message registered: %s", s))
-	}
-	messageTypeCache.Store(s, t)
-}
-
-// MessageType returns the message type for a named message.
-// It returns nil if not found.
-//
-// Deprecated: Use protoregistry.GlobalTypes.FindMessageByName instead.
-func MessageType(s messageName) reflect.Type {
-	if v, ok := messageTypeCache.Load(s); ok {
-		return v.(reflect.Type)
-	}
-
-	// Derive the message type from the v2 registry.
-	var t reflect.Type
-	if mt, _ := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(s)); mt != nil {
-		t = messageGoType(mt)
-	}
-
-	// If we could not get a concrete type, it is possible that it is a
-	// pseudo-message for a map entry.
-	if t == nil {
-		d, _ := protoregistry.GlobalFiles.FindDescriptorByName(protoreflect.FullName(s))
-		if md, _ := d.(protoreflect.MessageDescriptor); md != nil && md.IsMapEntry() {
-			kt := goTypeForField(md.Fields().ByNumber(1))
-			vt := goTypeForField(md.Fields().ByNumber(2))
-			t = reflect.MapOf(kt, vt)
-		}
-	}
-
-	// Locally cache the message type for the given name.
-	if t != nil {
-		v, _ := messageTypeCache.LoadOrStore(s, t)
-		return v.(reflect.Type)
-	}
-	return nil
-}
-
-func goTypeForField(fd protoreflect.FieldDescriptor) reflect.Type {
-	switch k := fd.Kind(); k {
-	case protoreflect.EnumKind:
-		if et, _ := protoregistry.GlobalTypes.FindEnumByName(fd.Enum().FullName()); et != nil {
-			return enumGoType(et)
-		}
-		return reflect.TypeOf(protoreflect.EnumNumber(0))
-	case protoreflect.MessageKind, protoreflect.GroupKind:
-		if mt, _ := protoregistry.GlobalTypes.FindMessageByName(fd.Message().FullName()); mt != nil {
-			return messageGoType(mt)
-		}
-		return reflect.TypeOf((*protoreflect.Message)(nil)).Elem()
-	default:
-		return reflect.TypeOf(fd.Default().Interface())
-	}
-}
-
-func enumGoType(et protoreflect.EnumType) reflect.Type {
-	return reflect.TypeOf(et.New(0))
-}
-
-func messageGoType(mt protoreflect.MessageType) reflect.Type {
-	return reflect.TypeOf(MessageV1(mt.Zero().Interface()))
-}
-
-// MessageName returns the full protobuf name for the given message type.
-//
-// Deprecated: Use protoreflect.MessageDescriptor.FullName instead.
-func MessageName(m Message) messageName {
-	if m == nil {
-		return ""
-	}
-	if m, ok := m.(interface{ XXX_MessageName() messageName }); ok {
-		return m.XXX_MessageName()
-	}
-	return messageName(protoimpl.X.MessageDescriptorOf(m).FullName())
-}
-
-// RegisterExtension is called from the generated code to register
-// the extension descriptor.
-//
-// Deprecated: Use protoregistry.GlobalTypes.RegisterExtension instead.
-func RegisterExtension(d *ExtensionDesc) {
-	if err := protoregistry.GlobalTypes.RegisterExtension(d); err != nil {
-		panic(err)
-	}
-}
-
-type extensionsByNumber = map[int32]*ExtensionDesc
-
-var extensionCache sync.Map // map[messageName]extensionsByNumber
-
-// RegisteredExtensions returns a map of the registered extensions for the
-// provided protobuf message, indexed by the extension field number.
-//
-// Deprecated: Use protoregistry.GlobalTypes.RangeExtensionsByMessage instead.
-func RegisteredExtensions(m Message) extensionsByNumber {
-	// Check whether the cache is stale. If the number of extensions for
-	// the given message differs, then it means that some extensions were
-	// recently registered upstream that we do not know about.
-	s := MessageName(m)
-	v, _ := extensionCache.Load(s)
-	xs, _ := v.(extensionsByNumber)
-	if protoregistry.GlobalTypes.NumExtensionsByMessage(protoreflect.FullName(s)) == len(xs) {
-		return xs // cache is up-to-date
-	}
-
-	// Cache is stale, re-compute the extensions map.
-	xs = make(extensionsByNumber)
-	protoregistry.GlobalTypes.RangeExtensionsByMessage(protoreflect.FullName(s), func(xt protoreflect.ExtensionType) bool {
-		if xd, ok := xt.(*ExtensionDesc); ok {
-			xs[int32(xt.TypeDescriptor().Number())] = xd
-		} else {
-			// TODO: This implies that the protoreflect.ExtensionType is a
-			// custom type not generated by protoc-gen-go. We could try and
-			// convert the type to an ExtensionDesc.
-		}
-		return true
-	})
-	extensionCache.Store(s, xs)
-	return xs
-}
diff --git a/vendor/github.com/golang/protobuf/proto/table_marshal.go b/vendor/github.com/golang/protobuf/proto/table_marshal.go
new file mode 100644
index 0000000..5cb11fa
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/table_marshal.go
@@ -0,0 +1,2776 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"unicode/utf8"
+)
+
+// a sizer takes a pointer to a field and the size of its tag, computes the size of
+// the encoded data.
+type sizer func(pointer, int) int
+
+// a marshaler takes a byte slice, a pointer to a field, and its tag (in wire format),
+// marshals the field to the end of the slice, returns the slice and error (if any).
+type marshaler func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error)
+
+// marshalInfo is the information used for marshaling a message.
+type marshalInfo struct {
+	typ          reflect.Type
+	fields       []*marshalFieldInfo
+	unrecognized field                      // offset of XXX_unrecognized
+	extensions   field                      // offset of XXX_InternalExtensions
+	v1extensions field                      // offset of XXX_extensions
+	sizecache    field                      // offset of XXX_sizecache
+	initialized  int32                      // 0 -- only typ is set, 1 -- fully initialized
+	messageset   bool                       // uses message set wire format
+	hasmarshaler bool                       // has custom marshaler
+	sync.RWMutex                            // protect extElems map, also for initialization
+	extElems     map[int32]*marshalElemInfo // info of extension elements
+}
+
+// marshalFieldInfo is the information used for marshaling a field of a message.
+type marshalFieldInfo struct {
+	field      field
+	wiretag    uint64 // tag in wire format
+	tagsize    int    // size of tag in wire format
+	sizer      sizer
+	marshaler  marshaler
+	isPointer  bool
+	required   bool                              // field is required
+	name       string                            // name of the field, for error reporting
+	oneofElems map[reflect.Type]*marshalElemInfo // info of oneof elements
+}
+
+// marshalElemInfo is the information used for marshaling an extension or oneof element.
+type marshalElemInfo struct {
+	wiretag   uint64 // tag in wire format
+	tagsize   int    // size of tag in wire format
+	sizer     sizer
+	marshaler marshaler
+	isptr     bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
+	deref     bool // dereference the pointer before operating on it; implies isptr
+}
+
+var (
+	marshalInfoMap  = map[reflect.Type]*marshalInfo{}
+	marshalInfoLock sync.Mutex
+)
+
+// getMarshalInfo returns the information to marshal a given type of message.
+// The info it returns may not necessarily initialized.
+// t is the type of the message (NOT the pointer to it).
+func getMarshalInfo(t reflect.Type) *marshalInfo {
+	marshalInfoLock.Lock()
+	u, ok := marshalInfoMap[t]
+	if !ok {
+		u = &marshalInfo{typ: t}
+		marshalInfoMap[t] = u
+	}
+	marshalInfoLock.Unlock()
+	return u
+}
+
+// Size is the entry point from generated code,
+// and should be ONLY called by generated code.
+// It computes the size of encoded data of msg.
+// a is a pointer to a place to store cached marshal info.
+func (a *InternalMessageInfo) Size(msg Message) int {
+	u := getMessageMarshalInfo(msg, a)
+	ptr := toPointer(&msg)
+	if ptr.isNil() {
+		// We get here if msg is a typed nil ((*SomeMessage)(nil)),
+		// so it satisfies the interface, and msg == nil wouldn't
+		// catch it. We don't want crash in this case.
+		return 0
+	}
+	return u.size(ptr)
+}
+
+// Marshal is the entry point from generated code,
+// and should be ONLY called by generated code.
+// It marshals msg to the end of b.
+// a is a pointer to a place to store cached marshal info.
+func (a *InternalMessageInfo) Marshal(b []byte, msg Message, deterministic bool) ([]byte, error) {
+	u := getMessageMarshalInfo(msg, a)
+	ptr := toPointer(&msg)
+	if ptr.isNil() {
+		// We get here if msg is a typed nil ((*SomeMessage)(nil)),
+		// so it satisfies the interface, and msg == nil wouldn't
+		// catch it. We don't want crash in this case.
+		return b, ErrNil
+	}
+	return u.marshal(b, ptr, deterministic)
+}
+
+func getMessageMarshalInfo(msg interface{}, a *InternalMessageInfo) *marshalInfo {
+	// u := a.marshal, but atomically.
+	// We use an atomic here to ensure memory consistency.
+	u := atomicLoadMarshalInfo(&a.marshal)
+	if u == nil {
+		// Get marshal information from type of message.
+		t := reflect.ValueOf(msg).Type()
+		if t.Kind() != reflect.Ptr {
+			panic(fmt.Sprintf("cannot handle non-pointer message type %v", t))
+		}
+		u = getMarshalInfo(t.Elem())
+		// Store it in the cache for later users.
+		// a.marshal = u, but atomically.
+		atomicStoreMarshalInfo(&a.marshal, u)
+	}
+	return u
+}
+
+// size is the main function to compute the size of the encoded data of a message.
+// ptr is the pointer to the message.
+func (u *marshalInfo) size(ptr pointer) int {
+	if atomic.LoadInt32(&u.initialized) == 0 {
+		u.computeMarshalInfo()
+	}
+
+	// If the message can marshal itself, let it do it, for compatibility.
+	// NOTE: This is not efficient.
+	if u.hasmarshaler {
+		m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
+		b, _ := m.Marshal()
+		return len(b)
+	}
+
+	n := 0
+	for _, f := range u.fields {
+		if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
+			// nil pointer always marshals to nothing
+			continue
+		}
+		n += f.sizer(ptr.offset(f.field), f.tagsize)
+	}
+	if u.extensions.IsValid() {
+		e := ptr.offset(u.extensions).toExtensions()
+		if u.messageset {
+			n += u.sizeMessageSet(e)
+		} else {
+			n += u.sizeExtensions(e)
+		}
+	}
+	if u.v1extensions.IsValid() {
+		m := *ptr.offset(u.v1extensions).toOldExtensions()
+		n += u.sizeV1Extensions(m)
+	}
+	if u.unrecognized.IsValid() {
+		s := *ptr.offset(u.unrecognized).toBytes()
+		n += len(s)
+	}
+	// cache the result for use in marshal
+	if u.sizecache.IsValid() {
+		atomic.StoreInt32(ptr.offset(u.sizecache).toInt32(), int32(n))
+	}
+	return n
+}
+
+// cachedsize gets the size from cache. If there is no cache (i.e. message is not generated),
+// fall back to compute the size.
+func (u *marshalInfo) cachedsize(ptr pointer) int {
+	if u.sizecache.IsValid() {
+		return int(atomic.LoadInt32(ptr.offset(u.sizecache).toInt32()))
+	}
+	return u.size(ptr)
+}
+
+// marshal is the main function to marshal a message. It takes a byte slice and appends
+// the encoded data to the end of the slice, returns the slice and error (if any).
+// ptr is the pointer to the message.
+// If deterministic is true, map is marshaled in deterministic order.
+func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte, error) {
+	if atomic.LoadInt32(&u.initialized) == 0 {
+		u.computeMarshalInfo()
+	}
+
+	// If the message can marshal itself, let it do it, for compatibility.
+	// NOTE: This is not efficient.
+	if u.hasmarshaler {
+		m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
+		b1, err := m.Marshal()
+		b = append(b, b1...)
+		return b, err
+	}
+
+	var err, errLater error
+	// The old marshaler encodes extensions at beginning.
+	if u.extensions.IsValid() {
+		e := ptr.offset(u.extensions).toExtensions()
+		if u.messageset {
+			b, err = u.appendMessageSet(b, e, deterministic)
+		} else {
+			b, err = u.appendExtensions(b, e, deterministic)
+		}
+		if err != nil {
+			return b, err
+		}
+	}
+	if u.v1extensions.IsValid() {
+		m := *ptr.offset(u.v1extensions).toOldExtensions()
+		b, err = u.appendV1Extensions(b, m, deterministic)
+		if err != nil {
+			return b, err
+		}
+	}
+	for _, f := range u.fields {
+		if f.required {
+			if ptr.offset(f.field).getPointer().isNil() {
+				// Required field is not set.
+				// We record the error but keep going, to give a complete marshaling.
+				if errLater == nil {
+					errLater = &RequiredNotSetError{f.name}
+				}
+				continue
+			}
+		}
+		if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
+			// nil pointer always marshals to nothing
+			continue
+		}
+		b, err = f.marshaler(b, ptr.offset(f.field), f.wiretag, deterministic)
+		if err != nil {
+			if err1, ok := err.(*RequiredNotSetError); ok {
+				// Required field in submessage is not set.
+				// We record the error but keep going, to give a complete marshaling.
+				if errLater == nil {
+					errLater = &RequiredNotSetError{f.name + "." + err1.field}
+				}
+				continue
+			}
+			if err == errRepeatedHasNil {
+				err = errors.New("proto: repeated field " + f.name + " has nil element")
+			}
+			if err == errInvalidUTF8 {
+				if errLater == nil {
+					fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
+					errLater = &invalidUTF8Error{fullName}
+				}
+				continue
+			}
+			return b, err
+		}
+	}
+	if u.unrecognized.IsValid() {
+		s := *ptr.offset(u.unrecognized).toBytes()
+		b = append(b, s...)
+	}
+	return b, errLater
+}
+
+// computeMarshalInfo initializes the marshal info.
+func (u *marshalInfo) computeMarshalInfo() {
+	u.Lock()
+	defer u.Unlock()
+	if u.initialized != 0 { // non-atomic read is ok as it is protected by the lock
+		return
+	}
+
+	t := u.typ
+	u.unrecognized = invalidField
+	u.extensions = invalidField
+	u.v1extensions = invalidField
+	u.sizecache = invalidField
+
+	// If the message can marshal itself, let it do it, for compatibility.
+	// NOTE: This is not efficient.
+	if reflect.PtrTo(t).Implements(marshalerType) {
+		u.hasmarshaler = true
+		atomic.StoreInt32(&u.initialized, 1)
+		return
+	}
+
+	// get oneof implementers
+	var oneofImplementers []interface{}
+	switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
+	case oneofFuncsIface:
+		_, _, _, oneofImplementers = m.XXX_OneofFuncs()
+	case oneofWrappersIface:
+		oneofImplementers = m.XXX_OneofWrappers()
+	}
+
+	n := t.NumField()
+
+	// deal with XXX fields first
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		if !strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+		switch f.Name {
+		case "XXX_sizecache":
+			u.sizecache = toField(&f)
+		case "XXX_unrecognized":
+			u.unrecognized = toField(&f)
+		case "XXX_InternalExtensions":
+			u.extensions = toField(&f)
+			u.messageset = f.Tag.Get("protobuf_messageset") == "1"
+		case "XXX_extensions":
+			u.v1extensions = toField(&f)
+		case "XXX_NoUnkeyedLiteral":
+			// nothing to do
+		default:
+			panic("unknown XXX field: " + f.Name)
+		}
+		n--
+	}
+
+	// normal fields
+	fields := make([]marshalFieldInfo, n) // batch allocation
+	u.fields = make([]*marshalFieldInfo, 0, n)
+	for i, j := 0, 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+		field := &fields[j]
+		j++
+		field.name = f.Name
+		u.fields = append(u.fields, field)
+		if f.Tag.Get("protobuf_oneof") != "" {
+			field.computeOneofFieldInfo(&f, oneofImplementers)
+			continue
+		}
+		if f.Tag.Get("protobuf") == "" {
+			// field has no tag (not in generated message), ignore it
+			u.fields = u.fields[:len(u.fields)-1]
+			j--
+			continue
+		}
+		field.computeMarshalFieldInfo(&f)
+	}
+
+	// fields are marshaled in tag order on the wire.
+	sort.Sort(byTag(u.fields))
+
+	atomic.StoreInt32(&u.initialized, 1)
+}
+
+// helper for sorting fields by tag
+type byTag []*marshalFieldInfo
+
+func (a byTag) Len() int           { return len(a) }
+func (a byTag) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }
+
+// getExtElemInfo returns the information to marshal an extension element.
+// The info it returns is initialized.
+func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
+	// get from cache first
+	u.RLock()
+	e, ok := u.extElems[desc.Field]
+	u.RUnlock()
+	if ok {
+		return e
+	}
+
+	t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct
+	tags := strings.Split(desc.Tag, ",")
+	tag, err := strconv.Atoi(tags[1])
+	if err != nil {
+		panic("tag is not an integer")
+	}
+	wt := wiretype(tags[0])
+	if t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct {
+		t = t.Elem()
+	}
+	sizer, marshaler := typeMarshaler(t, tags, false, false)
+	var deref bool
+	if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
+		t = reflect.PtrTo(t)
+		deref = true
+	}
+	e = &marshalElemInfo{
+		wiretag:   uint64(tag)<<3 | wt,
+		tagsize:   SizeVarint(uint64(tag) << 3),
+		sizer:     sizer,
+		marshaler: marshaler,
+		isptr:     t.Kind() == reflect.Ptr,
+		deref:     deref,
+	}
+
+	// update cache
+	u.Lock()
+	if u.extElems == nil {
+		u.extElems = make(map[int32]*marshalElemInfo)
+	}
+	u.extElems[desc.Field] = e
+	u.Unlock()
+	return e
+}
+
+// computeMarshalFieldInfo fills up the information to marshal a field.
+func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
+	// parse protobuf tag of the field.
+	// tag has format of "bytes,49,opt,name=foo,def=hello!"
+	tags := strings.Split(f.Tag.Get("protobuf"), ",")
+	if tags[0] == "" {
+		return
+	}
+	tag, err := strconv.Atoi(tags[1])
+	if err != nil {
+		panic("tag is not an integer")
+	}
+	wt := wiretype(tags[0])
+	if tags[2] == "req" {
+		fi.required = true
+	}
+	fi.setTag(f, tag, wt)
+	fi.setMarshaler(f, tags)
+}
+
+func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
+	fi.field = toField(f)
+	fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
+	fi.isPointer = true
+	fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
+	fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
+
+	ityp := f.Type // interface type
+	for _, o := range oneofImplementers {
+		t := reflect.TypeOf(o)
+		if !t.Implements(ityp) {
+			continue
+		}
+		sf := t.Elem().Field(0) // oneof implementer is a struct with a single field
+		tags := strings.Split(sf.Tag.Get("protobuf"), ",")
+		tag, err := strconv.Atoi(tags[1])
+		if err != nil {
+			panic("tag is not an integer")
+		}
+		wt := wiretype(tags[0])
+		sizer, marshaler := typeMarshaler(sf.Type, tags, false, true) // oneof should not omit any zero value
+		fi.oneofElems[t.Elem()] = &marshalElemInfo{
+			wiretag:   uint64(tag)<<3 | wt,
+			tagsize:   SizeVarint(uint64(tag) << 3),
+			sizer:     sizer,
+			marshaler: marshaler,
+		}
+	}
+}
+
+// wiretype returns the wire encoding of the type.
+func wiretype(encoding string) uint64 {
+	switch encoding {
+	case "fixed32":
+		return WireFixed32
+	case "fixed64":
+		return WireFixed64
+	case "varint", "zigzag32", "zigzag64":
+		return WireVarint
+	case "bytes":
+		return WireBytes
+	case "group":
+		return WireStartGroup
+	}
+	panic("unknown wire type " + encoding)
+}
+
+// setTag fills up the tag (in wire format) and its size in the info of a field.
+func (fi *marshalFieldInfo) setTag(f *reflect.StructField, tag int, wt uint64) {
+	fi.field = toField(f)
+	fi.wiretag = uint64(tag)<<3 | wt
+	fi.tagsize = SizeVarint(uint64(tag) << 3)
+}
+
+// setMarshaler fills up the sizer and marshaler in the info of a field.
+func (fi *marshalFieldInfo) setMarshaler(f *reflect.StructField, tags []string) {
+	switch f.Type.Kind() {
+	case reflect.Map:
+		// map field
+		fi.isPointer = true
+		fi.sizer, fi.marshaler = makeMapMarshaler(f)
+		return
+	case reflect.Ptr, reflect.Slice:
+		fi.isPointer = true
+	}
+	fi.sizer, fi.marshaler = typeMarshaler(f.Type, tags, true, false)
+}
+
+// typeMarshaler returns the sizer and marshaler of a given field.
+// t is the type of the field.
+// tags is the generated "protobuf" tag of the field.
+// If nozero is true, zero value is not marshaled to the wire.
+// If oneof is true, it is a oneof field.
+func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, marshaler) {
+	encoding := tags[0]
+
+	pointer := false
+	slice := false
+	if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
+		slice = true
+		t = t.Elem()
+	}
+	if t.Kind() == reflect.Ptr {
+		pointer = true
+		t = t.Elem()
+	}
+
+	packed := false
+	proto3 := false
+	validateUTF8 := true
+	for i := 2; i < len(tags); i++ {
+		if tags[i] == "packed" {
+			packed = true
+		}
+		if tags[i] == "proto3" {
+			proto3 = true
+		}
+	}
+	validateUTF8 = validateUTF8 && proto3
+
+	switch t.Kind() {
+	case reflect.Bool:
+		if pointer {
+			return sizeBoolPtr, appendBoolPtr
+		}
+		if slice {
+			if packed {
+				return sizeBoolPackedSlice, appendBoolPackedSlice
+			}
+			return sizeBoolSlice, appendBoolSlice
+		}
+		if nozero {
+			return sizeBoolValueNoZero, appendBoolValueNoZero
+		}
+		return sizeBoolValue, appendBoolValue
+	case reflect.Uint32:
+		switch encoding {
+		case "fixed32":
+			if pointer {
+				return sizeFixed32Ptr, appendFixed32Ptr
+			}
+			if slice {
+				if packed {
+					return sizeFixed32PackedSlice, appendFixed32PackedSlice
+				}
+				return sizeFixed32Slice, appendFixed32Slice
+			}
+			if nozero {
+				return sizeFixed32ValueNoZero, appendFixed32ValueNoZero
+			}
+			return sizeFixed32Value, appendFixed32Value
+		case "varint":
+			if pointer {
+				return sizeVarint32Ptr, appendVarint32Ptr
+			}
+			if slice {
+				if packed {
+					return sizeVarint32PackedSlice, appendVarint32PackedSlice
+				}
+				return sizeVarint32Slice, appendVarint32Slice
+			}
+			if nozero {
+				return sizeVarint32ValueNoZero, appendVarint32ValueNoZero
+			}
+			return sizeVarint32Value, appendVarint32Value
+		}
+	case reflect.Int32:
+		switch encoding {
+		case "fixed32":
+			if pointer {
+				return sizeFixedS32Ptr, appendFixedS32Ptr
+			}
+			if slice {
+				if packed {
+					return sizeFixedS32PackedSlice, appendFixedS32PackedSlice
+				}
+				return sizeFixedS32Slice, appendFixedS32Slice
+			}
+			if nozero {
+				return sizeFixedS32ValueNoZero, appendFixedS32ValueNoZero
+			}
+			return sizeFixedS32Value, appendFixedS32Value
+		case "varint":
+			if pointer {
+				return sizeVarintS32Ptr, appendVarintS32Ptr
+			}
+			if slice {
+				if packed {
+					return sizeVarintS32PackedSlice, appendVarintS32PackedSlice
+				}
+				return sizeVarintS32Slice, appendVarintS32Slice
+			}
+			if nozero {
+				return sizeVarintS32ValueNoZero, appendVarintS32ValueNoZero
+			}
+			return sizeVarintS32Value, appendVarintS32Value
+		case "zigzag32":
+			if pointer {
+				return sizeZigzag32Ptr, appendZigzag32Ptr
+			}
+			if slice {
+				if packed {
+					return sizeZigzag32PackedSlice, appendZigzag32PackedSlice
+				}
+				return sizeZigzag32Slice, appendZigzag32Slice
+			}
+			if nozero {
+				return sizeZigzag32ValueNoZero, appendZigzag32ValueNoZero
+			}
+			return sizeZigzag32Value, appendZigzag32Value
+		}
+	case reflect.Uint64:
+		switch encoding {
+		case "fixed64":
+			if pointer {
+				return sizeFixed64Ptr, appendFixed64Ptr
+			}
+			if slice {
+				if packed {
+					return sizeFixed64PackedSlice, appendFixed64PackedSlice
+				}
+				return sizeFixed64Slice, appendFixed64Slice
+			}
+			if nozero {
+				return sizeFixed64ValueNoZero, appendFixed64ValueNoZero
+			}
+			return sizeFixed64Value, appendFixed64Value
+		case "varint":
+			if pointer {
+				return sizeVarint64Ptr, appendVarint64Ptr
+			}
+			if slice {
+				if packed {
+					return sizeVarint64PackedSlice, appendVarint64PackedSlice
+				}
+				return sizeVarint64Slice, appendVarint64Slice
+			}
+			if nozero {
+				return sizeVarint64ValueNoZero, appendVarint64ValueNoZero
+			}
+			return sizeVarint64Value, appendVarint64Value
+		}
+	case reflect.Int64:
+		switch encoding {
+		case "fixed64":
+			if pointer {
+				return sizeFixedS64Ptr, appendFixedS64Ptr
+			}
+			if slice {
+				if packed {
+					return sizeFixedS64PackedSlice, appendFixedS64PackedSlice
+				}
+				return sizeFixedS64Slice, appendFixedS64Slice
+			}
+			if nozero {
+				return sizeFixedS64ValueNoZero, appendFixedS64ValueNoZero
+			}
+			return sizeFixedS64Value, appendFixedS64Value
+		case "varint":
+			if pointer {
+				return sizeVarintS64Ptr, appendVarintS64Ptr
+			}
+			if slice {
+				if packed {
+					return sizeVarintS64PackedSlice, appendVarintS64PackedSlice
+				}
+				return sizeVarintS64Slice, appendVarintS64Slice
+			}
+			if nozero {
+				return sizeVarintS64ValueNoZero, appendVarintS64ValueNoZero
+			}
+			return sizeVarintS64Value, appendVarintS64Value
+		case "zigzag64":
+			if pointer {
+				return sizeZigzag64Ptr, appendZigzag64Ptr
+			}
+			if slice {
+				if packed {
+					return sizeZigzag64PackedSlice, appendZigzag64PackedSlice
+				}
+				return sizeZigzag64Slice, appendZigzag64Slice
+			}
+			if nozero {
+				return sizeZigzag64ValueNoZero, appendZigzag64ValueNoZero
+			}
+			return sizeZigzag64Value, appendZigzag64Value
+		}
+	case reflect.Float32:
+		if pointer {
+			return sizeFloat32Ptr, appendFloat32Ptr
+		}
+		if slice {
+			if packed {
+				return sizeFloat32PackedSlice, appendFloat32PackedSlice
+			}
+			return sizeFloat32Slice, appendFloat32Slice
+		}
+		if nozero {
+			return sizeFloat32ValueNoZero, appendFloat32ValueNoZero
+		}
+		return sizeFloat32Value, appendFloat32Value
+	case reflect.Float64:
+		if pointer {
+			return sizeFloat64Ptr, appendFloat64Ptr
+		}
+		if slice {
+			if packed {
+				return sizeFloat64PackedSlice, appendFloat64PackedSlice
+			}
+			return sizeFloat64Slice, appendFloat64Slice
+		}
+		if nozero {
+			return sizeFloat64ValueNoZero, appendFloat64ValueNoZero
+		}
+		return sizeFloat64Value, appendFloat64Value
+	case reflect.String:
+		if validateUTF8 {
+			if pointer {
+				return sizeStringPtr, appendUTF8StringPtr
+			}
+			if slice {
+				return sizeStringSlice, appendUTF8StringSlice
+			}
+			if nozero {
+				return sizeStringValueNoZero, appendUTF8StringValueNoZero
+			}
+			return sizeStringValue, appendUTF8StringValue
+		}
+		if pointer {
+			return sizeStringPtr, appendStringPtr
+		}
+		if slice {
+			return sizeStringSlice, appendStringSlice
+		}
+		if nozero {
+			return sizeStringValueNoZero, appendStringValueNoZero
+		}
+		return sizeStringValue, appendStringValue
+	case reflect.Slice:
+		if slice {
+			return sizeBytesSlice, appendBytesSlice
+		}
+		if oneof {
+			// Oneof bytes field may also have "proto3" tag.
+			// We want to marshal it as a oneof field. Do this
+			// check before the proto3 check.
+			return sizeBytesOneof, appendBytesOneof
+		}
+		if proto3 {
+			return sizeBytes3, appendBytes3
+		}
+		return sizeBytes, appendBytes
+	case reflect.Struct:
+		switch encoding {
+		case "group":
+			if slice {
+				return makeGroupSliceMarshaler(getMarshalInfo(t))
+			}
+			return makeGroupMarshaler(getMarshalInfo(t))
+		case "bytes":
+			if slice {
+				return makeMessageSliceMarshaler(getMarshalInfo(t))
+			}
+			return makeMessageMarshaler(getMarshalInfo(t))
+		}
+	}
+	panic(fmt.Sprintf("unknown or mismatched type: type: %v, wire type: %v", t, encoding))
+}
+
+// Below are functions to size/marshal a specific type of a field.
+// They are stored in the field's info, and called by function pointers.
+// They have type sizer or marshaler.
+
+func sizeFixed32Value(_ pointer, tagsize int) int {
+	return 4 + tagsize
+}
+func sizeFixed32ValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toUint32()
+	if v == 0 {
+		return 0
+	}
+	return 4 + tagsize
+}
+func sizeFixed32Ptr(ptr pointer, tagsize int) int {
+	p := *ptr.toUint32Ptr()
+	if p == nil {
+		return 0
+	}
+	return 4 + tagsize
+}
+func sizeFixed32Slice(ptr pointer, tagsize int) int {
+	s := *ptr.toUint32Slice()
+	return (4 + tagsize) * len(s)
+}
+func sizeFixed32PackedSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toUint32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
+}
+func sizeFixedS32Value(_ pointer, tagsize int) int {
+	return 4 + tagsize
+}
+func sizeFixedS32ValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toInt32()
+	if v == 0 {
+		return 0
+	}
+	return 4 + tagsize
+}
+func sizeFixedS32Ptr(ptr pointer, tagsize int) int {
+	p := ptr.getInt32Ptr()
+	if p == nil {
+		return 0
+	}
+	return 4 + tagsize
+}
+func sizeFixedS32Slice(ptr pointer, tagsize int) int {
+	s := ptr.getInt32Slice()
+	return (4 + tagsize) * len(s)
+}
+func sizeFixedS32PackedSlice(ptr pointer, tagsize int) int {
+	s := ptr.getInt32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
+}
+func sizeFloat32Value(_ pointer, tagsize int) int {
+	return 4 + tagsize
+}
+func sizeFloat32ValueNoZero(ptr pointer, tagsize int) int {
+	v := math.Float32bits(*ptr.toFloat32())
+	if v == 0 {
+		return 0
+	}
+	return 4 + tagsize
+}
+func sizeFloat32Ptr(ptr pointer, tagsize int) int {
+	p := *ptr.toFloat32Ptr()
+	if p == nil {
+		return 0
+	}
+	return 4 + tagsize
+}
+func sizeFloat32Slice(ptr pointer, tagsize int) int {
+	s := *ptr.toFloat32Slice()
+	return (4 + tagsize) * len(s)
+}
+func sizeFloat32PackedSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toFloat32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
+}
+func sizeFixed64Value(_ pointer, tagsize int) int {
+	return 8 + tagsize
+}
+func sizeFixed64ValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toUint64()
+	if v == 0 {
+		return 0
+	}
+	return 8 + tagsize
+}
+func sizeFixed64Ptr(ptr pointer, tagsize int) int {
+	p := *ptr.toUint64Ptr()
+	if p == nil {
+		return 0
+	}
+	return 8 + tagsize
+}
+func sizeFixed64Slice(ptr pointer, tagsize int) int {
+	s := *ptr.toUint64Slice()
+	return (8 + tagsize) * len(s)
+}
+func sizeFixed64PackedSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toUint64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
+}
+func sizeFixedS64Value(_ pointer, tagsize int) int {
+	return 8 + tagsize
+}
+func sizeFixedS64ValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toInt64()
+	if v == 0 {
+		return 0
+	}
+	return 8 + tagsize
+}
+func sizeFixedS64Ptr(ptr pointer, tagsize int) int {
+	p := *ptr.toInt64Ptr()
+	if p == nil {
+		return 0
+	}
+	return 8 + tagsize
+}
+func sizeFixedS64Slice(ptr pointer, tagsize int) int {
+	s := *ptr.toInt64Slice()
+	return (8 + tagsize) * len(s)
+}
+func sizeFixedS64PackedSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toInt64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
+}
+func sizeFloat64Value(_ pointer, tagsize int) int {
+	return 8 + tagsize
+}
+func sizeFloat64ValueNoZero(ptr pointer, tagsize int) int {
+	v := math.Float64bits(*ptr.toFloat64())
+	if v == 0 {
+		return 0
+	}
+	return 8 + tagsize
+}
+func sizeFloat64Ptr(ptr pointer, tagsize int) int {
+	p := *ptr.toFloat64Ptr()
+	if p == nil {
+		return 0
+	}
+	return 8 + tagsize
+}
+func sizeFloat64Slice(ptr pointer, tagsize int) int {
+	s := *ptr.toFloat64Slice()
+	return (8 + tagsize) * len(s)
+}
+func sizeFloat64PackedSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toFloat64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
+}
+func sizeVarint32Value(ptr pointer, tagsize int) int {
+	v := *ptr.toUint32()
+	return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarint32ValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toUint32()
+	if v == 0 {
+		return 0
+	}
+	return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarint32Ptr(ptr pointer, tagsize int) int {
+	p := *ptr.toUint32Ptr()
+	if p == nil {
+		return 0
+	}
+	return SizeVarint(uint64(*p)) + tagsize
+}
+func sizeVarint32Slice(ptr pointer, tagsize int) int {
+	s := *ptr.toUint32Slice()
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v)) + tagsize
+	}
+	return n
+}
+func sizeVarint32PackedSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toUint32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v))
+	}
+	return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeVarintS32Value(ptr pointer, tagsize int) int {
+	v := *ptr.toInt32()
+	return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS32ValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toInt32()
+	if v == 0 {
+		return 0
+	}
+	return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS32Ptr(ptr pointer, tagsize int) int {
+	p := ptr.getInt32Ptr()
+	if p == nil {
+		return 0
+	}
+	return SizeVarint(uint64(*p)) + tagsize
+}
+func sizeVarintS32Slice(ptr pointer, tagsize int) int {
+	s := ptr.getInt32Slice()
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v)) + tagsize
+	}
+	return n
+}
+func sizeVarintS32PackedSlice(ptr pointer, tagsize int) int {
+	s := ptr.getInt32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v))
+	}
+	return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeVarint64Value(ptr pointer, tagsize int) int {
+	v := *ptr.toUint64()
+	return SizeVarint(v) + tagsize
+}
+func sizeVarint64ValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toUint64()
+	if v == 0 {
+		return 0
+	}
+	return SizeVarint(v) + tagsize
+}
+func sizeVarint64Ptr(ptr pointer, tagsize int) int {
+	p := *ptr.toUint64Ptr()
+	if p == nil {
+		return 0
+	}
+	return SizeVarint(*p) + tagsize
+}
+func sizeVarint64Slice(ptr pointer, tagsize int) int {
+	s := *ptr.toUint64Slice()
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(v) + tagsize
+	}
+	return n
+}
+func sizeVarint64PackedSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toUint64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(v)
+	}
+	return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeVarintS64Value(ptr pointer, tagsize int) int {
+	v := *ptr.toInt64()
+	return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS64ValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toInt64()
+	if v == 0 {
+		return 0
+	}
+	return SizeVarint(uint64(v)) + tagsize
+}
+func sizeVarintS64Ptr(ptr pointer, tagsize int) int {
+	p := *ptr.toInt64Ptr()
+	if p == nil {
+		return 0
+	}
+	return SizeVarint(uint64(*p)) + tagsize
+}
+func sizeVarintS64Slice(ptr pointer, tagsize int) int {
+	s := *ptr.toInt64Slice()
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v)) + tagsize
+	}
+	return n
+}
+func sizeVarintS64PackedSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toInt64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v))
+	}
+	return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeZigzag32Value(ptr pointer, tagsize int) int {
+	v := *ptr.toInt32()
+	return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+}
+func sizeZigzag32ValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toInt32()
+	if v == 0 {
+		return 0
+	}
+	return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+}
+func sizeZigzag32Ptr(ptr pointer, tagsize int) int {
+	p := ptr.getInt32Ptr()
+	if p == nil {
+		return 0
+	}
+	v := *p
+	return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+}
+func sizeZigzag32Slice(ptr pointer, tagsize int) int {
+	s := ptr.getInt32Slice()
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
+	}
+	return n
+}
+func sizeZigzag32PackedSlice(ptr pointer, tagsize int) int {
+	s := ptr.getInt32Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
+	}
+	return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeZigzag64Value(ptr pointer, tagsize int) int {
+	v := *ptr.toInt64()
+	return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+}
+func sizeZigzag64ValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toInt64()
+	if v == 0 {
+		return 0
+	}
+	return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+}
+func sizeZigzag64Ptr(ptr pointer, tagsize int) int {
+	p := *ptr.toInt64Ptr()
+	if p == nil {
+		return 0
+	}
+	v := *p
+	return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+}
+func sizeZigzag64Slice(ptr pointer, tagsize int) int {
+	s := *ptr.toInt64Slice()
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
+	}
+	return n
+}
+func sizeZigzag64PackedSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toInt64Slice()
+	if len(s) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
+	}
+	return n + SizeVarint(uint64(n)) + tagsize
+}
+func sizeBoolValue(_ pointer, tagsize int) int {
+	return 1 + tagsize
+}
+func sizeBoolValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toBool()
+	if !v {
+		return 0
+	}
+	return 1 + tagsize
+}
+func sizeBoolPtr(ptr pointer, tagsize int) int {
+	p := *ptr.toBoolPtr()
+	if p == nil {
+		return 0
+	}
+	return 1 + tagsize
+}
+func sizeBoolSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toBoolSlice()
+	return (1 + tagsize) * len(s)
+}
+func sizeBoolPackedSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toBoolSlice()
+	if len(s) == 0 {
+		return 0
+	}
+	return len(s) + SizeVarint(uint64(len(s))) + tagsize
+}
+func sizeStringValue(ptr pointer, tagsize int) int {
+	v := *ptr.toString()
+	return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeStringValueNoZero(ptr pointer, tagsize int) int {
+	v := *ptr.toString()
+	if v == "" {
+		return 0
+	}
+	return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeStringPtr(ptr pointer, tagsize int) int {
+	p := *ptr.toStringPtr()
+	if p == nil {
+		return 0
+	}
+	v := *p
+	return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeStringSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toStringSlice()
+	n := 0
+	for _, v := range s {
+		n += len(v) + SizeVarint(uint64(len(v))) + tagsize
+	}
+	return n
+}
+func sizeBytes(ptr pointer, tagsize int) int {
+	v := *ptr.toBytes()
+	if v == nil {
+		return 0
+	}
+	return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeBytes3(ptr pointer, tagsize int) int {
+	v := *ptr.toBytes()
+	if len(v) == 0 {
+		return 0
+	}
+	return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeBytesOneof(ptr pointer, tagsize int) int {
+	v := *ptr.toBytes()
+	return len(v) + SizeVarint(uint64(len(v))) + tagsize
+}
+func sizeBytesSlice(ptr pointer, tagsize int) int {
+	s := *ptr.toBytesSlice()
+	n := 0
+	for _, v := range s {
+		n += len(v) + SizeVarint(uint64(len(v))) + tagsize
+	}
+	return n
+}
+
+// appendFixed32 appends an encoded fixed32 to b.
+func appendFixed32(b []byte, v uint32) []byte {
+	b = append(b,
+		byte(v),
+		byte(v>>8),
+		byte(v>>16),
+		byte(v>>24))
+	return b
+}
+
+// appendFixed64 appends an encoded fixed64 to b.
+func appendFixed64(b []byte, v uint64) []byte {
+	b = append(b,
+		byte(v),
+		byte(v>>8),
+		byte(v>>16),
+		byte(v>>24),
+		byte(v>>32),
+		byte(v>>40),
+		byte(v>>48),
+		byte(v>>56))
+	return b
+}
+
+// appendVarint appends an encoded varint to b.
+func appendVarint(b []byte, v uint64) []byte {
+	// TODO: make 1-byte (maybe 2-byte) case inline-able, once we
+	// have non-leaf inliner.
+	switch {
+	case v < 1<<7:
+		b = append(b, byte(v))
+	case v < 1<<14:
+		b = append(b,
+			byte(v&0x7f|0x80),
+			byte(v>>7))
+	case v < 1<<21:
+		b = append(b,
+			byte(v&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte(v>>14))
+	case v < 1<<28:
+		b = append(b,
+			byte(v&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte(v>>21))
+	case v < 1<<35:
+		b = append(b,
+			byte(v&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte(v>>28))
+	case v < 1<<42:
+		b = append(b,
+			byte(v&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte((v>>28)&0x7f|0x80),
+			byte(v>>35))
+	case v < 1<<49:
+		b = append(b,
+			byte(v&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte((v>>28)&0x7f|0x80),
+			byte((v>>35)&0x7f|0x80),
+			byte(v>>42))
+	case v < 1<<56:
+		b = append(b,
+			byte(v&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte((v>>28)&0x7f|0x80),
+			byte((v>>35)&0x7f|0x80),
+			byte((v>>42)&0x7f|0x80),
+			byte(v>>49))
+	case v < 1<<63:
+		b = append(b,
+			byte(v&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte((v>>28)&0x7f|0x80),
+			byte((v>>35)&0x7f|0x80),
+			byte((v>>42)&0x7f|0x80),
+			byte((v>>49)&0x7f|0x80),
+			byte(v>>56))
+	default:
+		b = append(b,
+			byte(v&0x7f|0x80),
+			byte((v>>7)&0x7f|0x80),
+			byte((v>>14)&0x7f|0x80),
+			byte((v>>21)&0x7f|0x80),
+			byte((v>>28)&0x7f|0x80),
+			byte((v>>35)&0x7f|0x80),
+			byte((v>>42)&0x7f|0x80),
+			byte((v>>49)&0x7f|0x80),
+			byte((v>>56)&0x7f|0x80),
+			1)
+	}
+	return b
+}
+
+func appendFixed32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toUint32()
+	b = appendVarint(b, wiretag)
+	b = appendFixed32(b, v)
+	return b, nil
+}
+func appendFixed32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toUint32()
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed32(b, v)
+	return b, nil
+}
+func appendFixed32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toUint32Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed32(b, *p)
+	return b, nil
+}
+func appendFixed32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toUint32Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendFixed32(b, v)
+	}
+	return b, nil
+}
+func appendFixed32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toUint32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	b = appendVarint(b, uint64(4*len(s)))
+	for _, v := range s {
+		b = appendFixed32(b, v)
+	}
+	return b, nil
+}
+func appendFixedS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt32()
+	b = appendVarint(b, wiretag)
+	b = appendFixed32(b, uint32(v))
+	return b, nil
+}
+func appendFixedS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt32()
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed32(b, uint32(v))
+	return b, nil
+}
+func appendFixedS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := ptr.getInt32Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed32(b, uint32(*p))
+	return b, nil
+}
+func appendFixedS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := ptr.getInt32Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendFixed32(b, uint32(v))
+	}
+	return b, nil
+}
+func appendFixedS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := ptr.getInt32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	b = appendVarint(b, uint64(4*len(s)))
+	for _, v := range s {
+		b = appendFixed32(b, uint32(v))
+	}
+	return b, nil
+}
+func appendFloat32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := math.Float32bits(*ptr.toFloat32())
+	b = appendVarint(b, wiretag)
+	b = appendFixed32(b, v)
+	return b, nil
+}
+func appendFloat32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := math.Float32bits(*ptr.toFloat32())
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed32(b, v)
+	return b, nil
+}
+func appendFloat32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toFloat32Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed32(b, math.Float32bits(*p))
+	return b, nil
+}
+func appendFloat32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toFloat32Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendFixed32(b, math.Float32bits(v))
+	}
+	return b, nil
+}
+func appendFloat32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toFloat32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	b = appendVarint(b, uint64(4*len(s)))
+	for _, v := range s {
+		b = appendFixed32(b, math.Float32bits(v))
+	}
+	return b, nil
+}
+func appendFixed64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toUint64()
+	b = appendVarint(b, wiretag)
+	b = appendFixed64(b, v)
+	return b, nil
+}
+func appendFixed64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toUint64()
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed64(b, v)
+	return b, nil
+}
+func appendFixed64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toUint64Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed64(b, *p)
+	return b, nil
+}
+func appendFixed64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toUint64Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendFixed64(b, v)
+	}
+	return b, nil
+}
+func appendFixed64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toUint64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	b = appendVarint(b, uint64(8*len(s)))
+	for _, v := range s {
+		b = appendFixed64(b, v)
+	}
+	return b, nil
+}
+func appendFixedS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt64()
+	b = appendVarint(b, wiretag)
+	b = appendFixed64(b, uint64(v))
+	return b, nil
+}
+func appendFixedS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt64()
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed64(b, uint64(v))
+	return b, nil
+}
+func appendFixedS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toInt64Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed64(b, uint64(*p))
+	return b, nil
+}
+func appendFixedS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toInt64Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendFixed64(b, uint64(v))
+	}
+	return b, nil
+}
+func appendFixedS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toInt64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	b = appendVarint(b, uint64(8*len(s)))
+	for _, v := range s {
+		b = appendFixed64(b, uint64(v))
+	}
+	return b, nil
+}
+func appendFloat64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := math.Float64bits(*ptr.toFloat64())
+	b = appendVarint(b, wiretag)
+	b = appendFixed64(b, v)
+	return b, nil
+}
+func appendFloat64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := math.Float64bits(*ptr.toFloat64())
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed64(b, v)
+	return b, nil
+}
+func appendFloat64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toFloat64Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendFixed64(b, math.Float64bits(*p))
+	return b, nil
+}
+func appendFloat64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toFloat64Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendFixed64(b, math.Float64bits(v))
+	}
+	return b, nil
+}
+func appendFloat64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toFloat64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	b = appendVarint(b, uint64(8*len(s)))
+	for _, v := range s {
+		b = appendFixed64(b, math.Float64bits(v))
+	}
+	return b, nil
+}
+func appendVarint32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toUint32()
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(v))
+	return b, nil
+}
+func appendVarint32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toUint32()
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(v))
+	return b, nil
+}
+func appendVarint32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toUint32Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(*p))
+	return b, nil
+}
+func appendVarint32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toUint32Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+func appendVarint32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toUint32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	// compute size
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v))
+	}
+	b = appendVarint(b, uint64(n))
+	for _, v := range s {
+		b = appendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+func appendVarintS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt32()
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(v))
+	return b, nil
+}
+func appendVarintS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt32()
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(v))
+	return b, nil
+}
+func appendVarintS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := ptr.getInt32Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(*p))
+	return b, nil
+}
+func appendVarintS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := ptr.getInt32Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+func appendVarintS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := ptr.getInt32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	// compute size
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v))
+	}
+	b = appendVarint(b, uint64(n))
+	for _, v := range s {
+		b = appendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+func appendVarint64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toUint64()
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, v)
+	return b, nil
+}
+func appendVarint64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toUint64()
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, v)
+	return b, nil
+}
+func appendVarint64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toUint64Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, *p)
+	return b, nil
+}
+func appendVarint64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toUint64Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendVarint(b, v)
+	}
+	return b, nil
+}
+func appendVarint64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toUint64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	// compute size
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(v)
+	}
+	b = appendVarint(b, uint64(n))
+	for _, v := range s {
+		b = appendVarint(b, v)
+	}
+	return b, nil
+}
+func appendVarintS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt64()
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(v))
+	return b, nil
+}
+func appendVarintS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt64()
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(v))
+	return b, nil
+}
+func appendVarintS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toInt64Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(*p))
+	return b, nil
+}
+func appendVarintS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toInt64Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+func appendVarintS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toInt64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	// compute size
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v))
+	}
+	b = appendVarint(b, uint64(n))
+	for _, v := range s {
+		b = appendVarint(b, uint64(v))
+	}
+	return b, nil
+}
+func appendZigzag32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt32()
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+	return b, nil
+}
+func appendZigzag32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt32()
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+	return b, nil
+}
+func appendZigzag32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := ptr.getInt32Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	v := *p
+	b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+	return b, nil
+}
+func appendZigzag32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := ptr.getInt32Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+	}
+	return b, nil
+}
+func appendZigzag32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := ptr.getInt32Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	// compute size
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
+	}
+	b = appendVarint(b, uint64(n))
+	for _, v := range s {
+		b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
+	}
+	return b, nil
+}
+func appendZigzag64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt64()
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+	return b, nil
+}
+func appendZigzag64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toInt64()
+	if v == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+	return b, nil
+}
+func appendZigzag64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toInt64Ptr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	v := *p
+	b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+	return b, nil
+}
+func appendZigzag64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toInt64Slice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+	}
+	return b, nil
+}
+func appendZigzag64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toInt64Slice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	// compute size
+	n := 0
+	for _, v := range s {
+		n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
+	}
+	b = appendVarint(b, uint64(n))
+	for _, v := range s {
+		b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
+	}
+	return b, nil
+}
+func appendBoolValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toBool()
+	b = appendVarint(b, wiretag)
+	if v {
+		b = append(b, 1)
+	} else {
+		b = append(b, 0)
+	}
+	return b, nil
+}
+func appendBoolValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toBool()
+	if !v {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = append(b, 1)
+	return b, nil
+}
+
+func appendBoolPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toBoolPtr()
+	if p == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	if *p {
+		b = append(b, 1)
+	} else {
+		b = append(b, 0)
+	}
+	return b, nil
+}
+func appendBoolSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toBoolSlice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		if v {
+			b = append(b, 1)
+		} else {
+			b = append(b, 0)
+		}
+	}
+	return b, nil
+}
+func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toBoolSlice()
+	if len(s) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag&^7|WireBytes)
+	b = appendVarint(b, uint64(len(s)))
+	for _, v := range s {
+		if v {
+			b = append(b, 1)
+		} else {
+			b = append(b, 0)
+		}
+	}
+	return b, nil
+}
+func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toString()
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(len(v)))
+	b = append(b, v...)
+	return b, nil
+}
+func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toString()
+	if v == "" {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(len(v)))
+	b = append(b, v...)
+	return b, nil
+}
+func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	p := *ptr.toStringPtr()
+	if p == nil {
+		return b, nil
+	}
+	v := *p
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(len(v)))
+	b = append(b, v...)
+	return b, nil
+}
+func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toStringSlice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendVarint(b, uint64(len(v)))
+		b = append(b, v...)
+	}
+	return b, nil
+}
+func appendUTF8StringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	var invalidUTF8 bool
+	v := *ptr.toString()
+	if !utf8.ValidString(v) {
+		invalidUTF8 = true
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(len(v)))
+	b = append(b, v...)
+	if invalidUTF8 {
+		return b, errInvalidUTF8
+	}
+	return b, nil
+}
+func appendUTF8StringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	var invalidUTF8 bool
+	v := *ptr.toString()
+	if v == "" {
+		return b, nil
+	}
+	if !utf8.ValidString(v) {
+		invalidUTF8 = true
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(len(v)))
+	b = append(b, v...)
+	if invalidUTF8 {
+		return b, errInvalidUTF8
+	}
+	return b, nil
+}
+func appendUTF8StringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	var invalidUTF8 bool
+	p := *ptr.toStringPtr()
+	if p == nil {
+		return b, nil
+	}
+	v := *p
+	if !utf8.ValidString(v) {
+		invalidUTF8 = true
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(len(v)))
+	b = append(b, v...)
+	if invalidUTF8 {
+		return b, errInvalidUTF8
+	}
+	return b, nil
+}
+func appendUTF8StringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	var invalidUTF8 bool
+	s := *ptr.toStringSlice()
+	for _, v := range s {
+		if !utf8.ValidString(v) {
+			invalidUTF8 = true
+		}
+		b = appendVarint(b, wiretag)
+		b = appendVarint(b, uint64(len(v)))
+		b = append(b, v...)
+	}
+	if invalidUTF8 {
+		return b, errInvalidUTF8
+	}
+	return b, nil
+}
+func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toBytes()
+	if v == nil {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(len(v)))
+	b = append(b, v...)
+	return b, nil
+}
+func appendBytes3(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toBytes()
+	if len(v) == 0 {
+		return b, nil
+	}
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(len(v)))
+	b = append(b, v...)
+	return b, nil
+}
+func appendBytesOneof(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	v := *ptr.toBytes()
+	b = appendVarint(b, wiretag)
+	b = appendVarint(b, uint64(len(v)))
+	b = append(b, v...)
+	return b, nil
+}
+func appendBytesSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
+	s := *ptr.toBytesSlice()
+	for _, v := range s {
+		b = appendVarint(b, wiretag)
+		b = appendVarint(b, uint64(len(v)))
+		b = append(b, v...)
+	}
+	return b, nil
+}
+
+// makeGroupMarshaler returns the sizer and marshaler for a group.
+// u is the marshal info of the underlying message.
+func makeGroupMarshaler(u *marshalInfo) (sizer, marshaler) {
+	return func(ptr pointer, tagsize int) int {
+			p := ptr.getPointer()
+			if p.isNil() {
+				return 0
+			}
+			return u.size(p) + 2*tagsize
+		},
+		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+			p := ptr.getPointer()
+			if p.isNil() {
+				return b, nil
+			}
+			var err error
+			b = appendVarint(b, wiretag) // start group
+			b, err = u.marshal(b, p, deterministic)
+			b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
+			return b, err
+		}
+}
+
+// makeGroupSliceMarshaler returns the sizer and marshaler for a group slice.
+// u is the marshal info of the underlying message.
+func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+	return func(ptr pointer, tagsize int) int {
+			s := ptr.getPointerSlice()
+			n := 0
+			for _, v := range s {
+				if v.isNil() {
+					continue
+				}
+				n += u.size(v) + 2*tagsize
+			}
+			return n
+		},
+		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+			s := ptr.getPointerSlice()
+			var err error
+			var nerr nonFatal
+			for _, v := range s {
+				if v.isNil() {
+					return b, errRepeatedHasNil
+				}
+				b = appendVarint(b, wiretag) // start group
+				b, err = u.marshal(b, v, deterministic)
+				b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
+				if !nerr.Merge(err) {
+					if err == ErrNil {
+						err = errRepeatedHasNil
+					}
+					return b, err
+				}
+			}
+			return b, nerr.E
+		}
+}
+
+// makeMessageMarshaler returns the sizer and marshaler for a message field.
+// u is the marshal info of the message.
+func makeMessageMarshaler(u *marshalInfo) (sizer, marshaler) {
+	return func(ptr pointer, tagsize int) int {
+			p := ptr.getPointer()
+			if p.isNil() {
+				return 0
+			}
+			siz := u.size(p)
+			return siz + SizeVarint(uint64(siz)) + tagsize
+		},
+		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+			p := ptr.getPointer()
+			if p.isNil() {
+				return b, nil
+			}
+			b = appendVarint(b, wiretag)
+			siz := u.cachedsize(p)
+			b = appendVarint(b, uint64(siz))
+			return u.marshal(b, p, deterministic)
+		}
+}
+
+// makeMessageSliceMarshaler returns the sizer and marshaler for a message slice.
+// u is the marshal info of the message.
+func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
+	return func(ptr pointer, tagsize int) int {
+			s := ptr.getPointerSlice()
+			n := 0
+			for _, v := range s {
+				if v.isNil() {
+					continue
+				}
+				siz := u.size(v)
+				n += siz + SizeVarint(uint64(siz)) + tagsize
+			}
+			return n
+		},
+		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
+			s := ptr.getPointerSlice()
+			var err error
+			var nerr nonFatal
+			for _, v := range s {
+				if v.isNil() {
+					return b, errRepeatedHasNil
+				}
+				b = appendVarint(b, wiretag)
+				siz := u.cachedsize(v)
+				b = appendVarint(b, uint64(siz))
+				b, err = u.marshal(b, v, deterministic)
+
+				if !nerr.Merge(err) {
+					if err == ErrNil {
+						err = errRepeatedHasNil
+					}
+					return b, err
+				}
+			}
+			return b, nerr.E
+		}
+}
+
+// makeMapMarshaler returns the sizer and marshaler for a map field.
+// f is the pointer to the reflect data structure of the field.
+func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
+	// figure out key and value type
+	t := f.Type
+	keyType := t.Key()
+	valType := t.Elem()
+	keyTags := strings.Split(f.Tag.Get("protobuf_key"), ",")
+	valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
+	keySizer, keyMarshaler := typeMarshaler(keyType, keyTags, false, false) // don't omit zero value in map
+	valSizer, valMarshaler := typeMarshaler(valType, valTags, false, false) // don't omit zero value in map
+	keyWireTag := 1<<3 | wiretype(keyTags[0])
+	valWireTag := 2<<3 | wiretype(valTags[0])
+
+	// We create an interface to get the addresses of the map key and value.
+	// If value is pointer-typed, the interface is a direct interface, the
+	// idata itself is the value. Otherwise, the idata is the pointer to the
+	// value.
+	// Key cannot be pointer-typed.
+	valIsPtr := valType.Kind() == reflect.Ptr
+
+	// If value is a message with nested maps, calling
+	// valSizer in marshal may be quadratic. We should use
+	// cached version in marshal (but not in size).
+	// If value is not message type, we don't have size cache,
+	// but it cannot be nested either. Just use valSizer.
+	valCachedSizer := valSizer
+	if valIsPtr && valType.Elem().Kind() == reflect.Struct {
+		u := getMarshalInfo(valType.Elem())
+		valCachedSizer = func(ptr pointer, tagsize int) int {
+			// Same as message sizer, but use cache.
+			p := ptr.getPointer()
+			if p.isNil() {
+				return 0
+			}
+			siz := u.cachedsize(p)
+			return siz + SizeVarint(uint64(siz)) + tagsize
+		}
+	}
+	return func(ptr pointer, tagsize int) int {
+			m := ptr.asPointerTo(t).Elem() // the map
+			n := 0
+			for _, k := range m.MapKeys() {
+				ki := k.Interface()
+				vi := m.MapIndex(k).Interface()
+				kaddr := toAddrPointer(&ki, false, false)      // pointer to key
+				vaddr := toAddrPointer(&vi, valIsPtr, false)   // pointer to value
+				siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
+				n += siz + SizeVarint(uint64(siz)) + tagsize
+			}
+			return n
+		},
+		func(b []byte, ptr pointer, tag uint64, deterministic bool) ([]byte, error) {
+			m := ptr.asPointerTo(t).Elem() // the map
+			var err error
+			keys := m.MapKeys()
+			if len(keys) > 1 && deterministic {
+				sort.Sort(mapKeys(keys))
+			}
+
+			var nerr nonFatal
+			for _, k := range keys {
+				ki := k.Interface()
+				vi := m.MapIndex(k).Interface()
+				kaddr := toAddrPointer(&ki, false, false)    // pointer to key
+				vaddr := toAddrPointer(&vi, valIsPtr, false) // pointer to value
+				b = appendVarint(b, tag)
+				siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
+				b = appendVarint(b, uint64(siz))
+				b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic)
+				if !nerr.Merge(err) {
+					return b, err
+				}
+				b, err = valMarshaler(b, vaddr, valWireTag, deterministic)
+				if err != ErrNil && !nerr.Merge(err) { // allow nil value in map
+					return b, err
+				}
+			}
+			return b, nerr.E
+		}
+}
+
+// makeOneOfMarshaler returns the sizer and marshaler for a oneof field.
+// fi is the marshal info of the field.
+// f is the pointer to the reflect data structure of the field.
+func makeOneOfMarshaler(fi *marshalFieldInfo, f *reflect.StructField) (sizer, marshaler) {
+	// Oneof field is an interface. We need to get the actual data type on the fly.
+	t := f.Type
+	return func(ptr pointer, _ int) int {
+			p := ptr.getInterfacePointer()
+			if p.isNil() {
+				return 0
+			}
+			v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
+			telem := v.Type()
+			e := fi.oneofElems[telem]
+			return e.sizer(p, e.tagsize)
+		},
+		func(b []byte, ptr pointer, _ uint64, deterministic bool) ([]byte, error) {
+			p := ptr.getInterfacePointer()
+			if p.isNil() {
+				return b, nil
+			}
+			v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
+			telem := v.Type()
+			if telem.Field(0).Type.Kind() == reflect.Ptr && p.getPointer().isNil() {
+				return b, errOneofHasNil
+			}
+			e := fi.oneofElems[telem]
+			return e.marshaler(b, p, e.wiretag, deterministic)
+		}
+}
+
+// sizeExtensions computes the size of encoded data for a XXX_InternalExtensions field.
+func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
+	m, mu := ext.extensionsRead()
+	if m == nil {
+		return 0
+	}
+	mu.Lock()
+
+	n := 0
+	for _, e := range m {
+		if e.value == nil || e.desc == nil {
+			// Extension is only in its encoded form.
+			n += len(e.enc)
+			continue
+		}
+
+		// We don't skip extensions that have an encoded form set,
+		// because the extension value may have been mutated after
+		// the last time this function was called.
+		ei := u.getExtElemInfo(e.desc)
+		v := e.value
+		p := toAddrPointer(&v, ei.isptr, ei.deref)
+		n += ei.sizer(p, ei.tagsize)
+	}
+	mu.Unlock()
+	return n
+}
+
+// appendExtensions marshals a XXX_InternalExtensions field to the end of byte slice b.
+func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
+	m, mu := ext.extensionsRead()
+	if m == nil {
+		return b, nil
+	}
+	mu.Lock()
+	defer mu.Unlock()
+
+	var err error
+	var nerr nonFatal
+
+	// Fast-path for common cases: zero or one extensions.
+	// Don't bother sorting the keys.
+	if len(m) <= 1 {
+		for _, e := range m {
+			if e.value == nil || e.desc == nil {
+				// Extension is only in its encoded form.
+				b = append(b, e.enc...)
+				continue
+			}
+
+			// We don't skip extensions that have an encoded form set,
+			// because the extension value may have been mutated after
+			// the last time this function was called.
+
+			ei := u.getExtElemInfo(e.desc)
+			v := e.value
+			p := toAddrPointer(&v, ei.isptr, ei.deref)
+			b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
+			if !nerr.Merge(err) {
+				return b, err
+			}
+		}
+		return b, nerr.E
+	}
+
+	// Sort the keys to provide a deterministic encoding.
+	// Not sure this is required, but the old code does it.
+	keys := make([]int, 0, len(m))
+	for k := range m {
+		keys = append(keys, int(k))
+	}
+	sort.Ints(keys)
+
+	for _, k := range keys {
+		e := m[int32(k)]
+		if e.value == nil || e.desc == nil {
+			// Extension is only in its encoded form.
+			b = append(b, e.enc...)
+			continue
+		}
+
+		// We don't skip extensions that have an encoded form set,
+		// because the extension value may have been mutated after
+		// the last time this function was called.
+
+		ei := u.getExtElemInfo(e.desc)
+		v := e.value
+		p := toAddrPointer(&v, ei.isptr, ei.deref)
+		b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
+		if !nerr.Merge(err) {
+			return b, err
+		}
+	}
+	return b, nerr.E
+}
+
+// message set format is:
+//   message MessageSet {
+//     repeated group Item = 1 {
+//       required int32 type_id = 2;
+//       required string message = 3;
+//     };
+//   }
+
+// sizeMessageSet computes the size of encoded data for a XXX_InternalExtensions field
+// in message set format (above).
+func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
+	m, mu := ext.extensionsRead()
+	if m == nil {
+		return 0
+	}
+	mu.Lock()
+
+	n := 0
+	for id, e := range m {
+		n += 2                          // start group, end group. tag = 1 (size=1)
+		n += SizeVarint(uint64(id)) + 1 // type_id, tag = 2 (size=1)
+
+		if e.value == nil || e.desc == nil {
+			// Extension is only in its encoded form.
+			msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
+			siz := len(msgWithLen)
+			n += siz + 1 // message, tag = 3 (size=1)
+			continue
+		}
+
+		// We don't skip extensions that have an encoded form set,
+		// because the extension value may have been mutated after
+		// the last time this function was called.
+
+		ei := u.getExtElemInfo(e.desc)
+		v := e.value
+		p := toAddrPointer(&v, ei.isptr, ei.deref)
+		n += ei.sizer(p, 1) // message, tag = 3 (size=1)
+	}
+	mu.Unlock()
+	return n
+}
+
+// appendMessageSet marshals a XXX_InternalExtensions field in message set format (above)
+// to the end of byte slice b.
+func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
+	m, mu := ext.extensionsRead()
+	if m == nil {
+		return b, nil
+	}
+	mu.Lock()
+	defer mu.Unlock()
+
+	var err error
+	var nerr nonFatal
+
+	// Fast-path for common cases: zero or one extensions.
+	// Don't bother sorting the keys.
+	if len(m) <= 1 {
+		for id, e := range m {
+			b = append(b, 1<<3|WireStartGroup)
+			b = append(b, 2<<3|WireVarint)
+			b = appendVarint(b, uint64(id))
+
+			if e.value == nil || e.desc == nil {
+				// Extension is only in its encoded form.
+				msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
+				b = append(b, 3<<3|WireBytes)
+				b = append(b, msgWithLen...)
+				b = append(b, 1<<3|WireEndGroup)
+				continue
+			}
+
+			// We don't skip extensions that have an encoded form set,
+			// because the extension value may have been mutated after
+			// the last time this function was called.
+
+			ei := u.getExtElemInfo(e.desc)
+			v := e.value
+			p := toAddrPointer(&v, ei.isptr, ei.deref)
+			b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
+			if !nerr.Merge(err) {
+				return b, err
+			}
+			b = append(b, 1<<3|WireEndGroup)
+		}
+		return b, nerr.E
+	}
+
+	// Sort the keys to provide a deterministic encoding.
+	keys := make([]int, 0, len(m))
+	for k := range m {
+		keys = append(keys, int(k))
+	}
+	sort.Ints(keys)
+
+	for _, id := range keys {
+		e := m[int32(id)]
+		b = append(b, 1<<3|WireStartGroup)
+		b = append(b, 2<<3|WireVarint)
+		b = appendVarint(b, uint64(id))
+
+		if e.value == nil || e.desc == nil {
+			// Extension is only in its encoded form.
+			msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
+			b = append(b, 3<<3|WireBytes)
+			b = append(b, msgWithLen...)
+			b = append(b, 1<<3|WireEndGroup)
+			continue
+		}
+
+		// We don't skip extensions that have an encoded form set,
+		// because the extension value may have been mutated after
+		// the last time this function was called.
+
+		ei := u.getExtElemInfo(e.desc)
+		v := e.value
+		p := toAddrPointer(&v, ei.isptr, ei.deref)
+		b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
+		b = append(b, 1<<3|WireEndGroup)
+		if !nerr.Merge(err) {
+			return b, err
+		}
+	}
+	return b, nerr.E
+}
+
+// sizeV1Extensions computes the size of encoded data for a V1-API extension field.
+func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
+	if m == nil {
+		return 0
+	}
+
+	n := 0
+	for _, e := range m {
+		if e.value == nil || e.desc == nil {
+			// Extension is only in its encoded form.
+			n += len(e.enc)
+			continue
+		}
+
+		// We don't skip extensions that have an encoded form set,
+		// because the extension value may have been mutated after
+		// the last time this function was called.
+
+		ei := u.getExtElemInfo(e.desc)
+		v := e.value
+		p := toAddrPointer(&v, ei.isptr, ei.deref)
+		n += ei.sizer(p, ei.tagsize)
+	}
+	return n
+}
+
+// appendV1Extensions marshals a V1-API extension field to the end of byte slice b.
+func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, deterministic bool) ([]byte, error) {
+	if m == nil {
+		return b, nil
+	}
+
+	// Sort the keys to provide a deterministic encoding.
+	keys := make([]int, 0, len(m))
+	for k := range m {
+		keys = append(keys, int(k))
+	}
+	sort.Ints(keys)
+
+	var err error
+	var nerr nonFatal
+	for _, k := range keys {
+		e := m[int32(k)]
+		if e.value == nil || e.desc == nil {
+			// Extension is only in its encoded form.
+			b = append(b, e.enc...)
+			continue
+		}
+
+		// We don't skip extensions that have an encoded form set,
+		// because the extension value may have been mutated after
+		// the last time this function was called.
+
+		ei := u.getExtElemInfo(e.desc)
+		v := e.value
+		p := toAddrPointer(&v, ei.isptr, ei.deref)
+		b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
+		if !nerr.Merge(err) {
+			return b, err
+		}
+	}
+	return b, nerr.E
+}
+
+// newMarshaler is the interface representing objects that can marshal themselves.
+//
+// This exists to support protoc-gen-go generated messages.
+// The proto package will stop type-asserting to this interface in the future.
+//
+// DO NOT DEPEND ON THIS.
+type newMarshaler interface {
+	XXX_Size() int
+	XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
+}
+
+// Size returns the encoded size of a protocol buffer message.
+// This is the main entry point.
+func Size(pb Message) int {
+	if m, ok := pb.(newMarshaler); ok {
+		return m.XXX_Size()
+	}
+	if m, ok := pb.(Marshaler); ok {
+		// If the message can marshal itself, let it do it, for compatibility.
+		// NOTE: This is not efficient.
+		b, _ := m.Marshal()
+		return len(b)
+	}
+	// in case somehow we didn't generate the wrapper
+	if pb == nil {
+		return 0
+	}
+	var info InternalMessageInfo
+	return info.Size(pb)
+}
+
+// Marshal takes a protocol buffer message
+// and encodes it into the wire format, returning the data.
+// This is the main entry point.
+func Marshal(pb Message) ([]byte, error) {
+	if m, ok := pb.(newMarshaler); ok {
+		siz := m.XXX_Size()
+		b := make([]byte, 0, siz)
+		return m.XXX_Marshal(b, false)
+	}
+	if m, ok := pb.(Marshaler); ok {
+		// If the message can marshal itself, let it do it, for compatibility.
+		// NOTE: This is not efficient.
+		return m.Marshal()
+	}
+	// in case somehow we didn't generate the wrapper
+	if pb == nil {
+		return nil, ErrNil
+	}
+	var info InternalMessageInfo
+	siz := info.Size(pb)
+	b := make([]byte, 0, siz)
+	return info.Marshal(b, pb, false)
+}
+
+// Marshal takes a protocol buffer message
+// and encodes it into the wire format, writing the result to the
+// Buffer.
+// This is an alternative entry point. It is not necessary to use
+// a Buffer for most applications.
+func (p *Buffer) Marshal(pb Message) error {
+	var err error
+	if m, ok := pb.(newMarshaler); ok {
+		siz := m.XXX_Size()
+		p.grow(siz) // make sure buf has enough capacity
+		p.buf, err = m.XXX_Marshal(p.buf, p.deterministic)
+		return err
+	}
+	if m, ok := pb.(Marshaler); ok {
+		// If the message can marshal itself, let it do it, for compatibility.
+		// NOTE: This is not efficient.
+		b, err := m.Marshal()
+		p.buf = append(p.buf, b...)
+		return err
+	}
+	// in case somehow we didn't generate the wrapper
+	if pb == nil {
+		return ErrNil
+	}
+	var info InternalMessageInfo
+	siz := info.Size(pb)
+	p.grow(siz) // make sure buf has enough capacity
+	p.buf, err = info.Marshal(p.buf, pb, p.deterministic)
+	return err
+}
+
+// grow grows the buffer's capacity, if necessary, to guarantee space for
+// another n bytes. After grow(n), at least n bytes can be written to the
+// buffer without another allocation.
+func (p *Buffer) grow(n int) {
+	need := len(p.buf) + n
+	if need <= cap(p.buf) {
+		return
+	}
+	newCap := len(p.buf) * 2
+	if newCap < need {
+		newCap = need
+	}
+	p.buf = append(make([]byte, 0, newCap), p.buf...)
+}
diff --git a/vendor/github.com/golang/protobuf/proto/table_merge.go b/vendor/github.com/golang/protobuf/proto/table_merge.go
new file mode 100644
index 0000000..5525def
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/table_merge.go
@@ -0,0 +1,654 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+	"sync/atomic"
+)
+
+// Merge merges the src message into dst.
+// This assumes that dst and src of the same type and are non-nil.
+func (a *InternalMessageInfo) Merge(dst, src Message) {
+	mi := atomicLoadMergeInfo(&a.merge)
+	if mi == nil {
+		mi = getMergeInfo(reflect.TypeOf(dst).Elem())
+		atomicStoreMergeInfo(&a.merge, mi)
+	}
+	mi.merge(toPointer(&dst), toPointer(&src))
+}
+
+type mergeInfo struct {
+	typ reflect.Type
+
+	initialized int32 // 0: only typ is valid, 1: everything is valid
+	lock        sync.Mutex
+
+	fields       []mergeFieldInfo
+	unrecognized field // Offset of XXX_unrecognized
+}
+
+type mergeFieldInfo struct {
+	field field // Offset of field, guaranteed to be valid
+
+	// isPointer reports whether the value in the field is a pointer.
+	// This is true for the following situations:
+	//	* Pointer to struct
+	//	* Pointer to basic type (proto2 only)
+	//	* Slice (first value in slice header is a pointer)
+	//	* String (first value in string header is a pointer)
+	isPointer bool
+
+	// basicWidth reports the width of the field assuming that it is directly
+	// embedded in the struct (as is the case for basic types in proto3).
+	// The possible values are:
+	// 	0: invalid
+	//	1: bool
+	//	4: int32, uint32, float32
+	//	8: int64, uint64, float64
+	basicWidth int
+
+	// Where dst and src are pointers to the types being merged.
+	merge func(dst, src pointer)
+}
+
+var (
+	mergeInfoMap  = map[reflect.Type]*mergeInfo{}
+	mergeInfoLock sync.Mutex
+)
+
+func getMergeInfo(t reflect.Type) *mergeInfo {
+	mergeInfoLock.Lock()
+	defer mergeInfoLock.Unlock()
+	mi := mergeInfoMap[t]
+	if mi == nil {
+		mi = &mergeInfo{typ: t}
+		mergeInfoMap[t] = mi
+	}
+	return mi
+}
+
+// merge merges src into dst assuming they are both of type *mi.typ.
+func (mi *mergeInfo) merge(dst, src pointer) {
+	if dst.isNil() {
+		panic("proto: nil destination")
+	}
+	if src.isNil() {
+		return // Nothing to do.
+	}
+
+	if atomic.LoadInt32(&mi.initialized) == 0 {
+		mi.computeMergeInfo()
+	}
+
+	for _, fi := range mi.fields {
+		sfp := src.offset(fi.field)
+
+		// As an optimization, we can avoid the merge function call cost
+		// if we know for sure that the source will have no effect
+		// by checking if it is the zero value.
+		if unsafeAllowed {
+			if fi.isPointer && sfp.getPointer().isNil() { // Could be slice or string
+				continue
+			}
+			if fi.basicWidth > 0 {
+				switch {
+				case fi.basicWidth == 1 && !*sfp.toBool():
+					continue
+				case fi.basicWidth == 4 && *sfp.toUint32() == 0:
+					continue
+				case fi.basicWidth == 8 && *sfp.toUint64() == 0:
+					continue
+				}
+			}
+		}
+
+		dfp := dst.offset(fi.field)
+		fi.merge(dfp, sfp)
+	}
+
+	// TODO: Make this faster?
+	out := dst.asPointerTo(mi.typ).Elem()
+	in := src.asPointerTo(mi.typ).Elem()
+	if emIn, err := extendable(in.Addr().Interface()); err == nil {
+		emOut, _ := extendable(out.Addr().Interface())
+		mIn, muIn := emIn.extensionsRead()
+		if mIn != nil {
+			mOut := emOut.extensionsWrite()
+			muIn.Lock()
+			mergeExtension(mOut, mIn)
+			muIn.Unlock()
+		}
+	}
+
+	if mi.unrecognized.IsValid() {
+		if b := *src.offset(mi.unrecognized).toBytes(); len(b) > 0 {
+			*dst.offset(mi.unrecognized).toBytes() = append([]byte(nil), b...)
+		}
+	}
+}
+
+func (mi *mergeInfo) computeMergeInfo() {
+	mi.lock.Lock()
+	defer mi.lock.Unlock()
+	if mi.initialized != 0 {
+		return
+	}
+	t := mi.typ
+	n := t.NumField()
+
+	props := GetProperties(t)
+	for i := 0; i < n; i++ {
+		f := t.Field(i)
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+
+		mfi := mergeFieldInfo{field: toField(&f)}
+		tf := f.Type
+
+		// As an optimization, we can avoid the merge function call cost
+		// if we know for sure that the source will have no effect
+		// by checking if it is the zero value.
+		if unsafeAllowed {
+			switch tf.Kind() {
+			case reflect.Ptr, reflect.Slice, reflect.String:
+				// As a special case, we assume slices and strings are pointers
+				// since we know that the first field in the SliceSlice or
+				// StringHeader is a data pointer.
+				mfi.isPointer = true
+			case reflect.Bool:
+				mfi.basicWidth = 1
+			case reflect.Int32, reflect.Uint32, reflect.Float32:
+				mfi.basicWidth = 4
+			case reflect.Int64, reflect.Uint64, reflect.Float64:
+				mfi.basicWidth = 8
+			}
+		}
+
+		// Unwrap tf to get at its most basic type.
+		var isPointer, isSlice bool
+		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
+			isSlice = true
+			tf = tf.Elem()
+		}
+		if tf.Kind() == reflect.Ptr {
+			isPointer = true
+			tf = tf.Elem()
+		}
+		if isPointer && isSlice && tf.Kind() != reflect.Struct {
+			panic("both pointer and slice for basic type in " + tf.Name())
+		}
+
+		switch tf.Kind() {
+		case reflect.Int32:
+			switch {
+			case isSlice: // E.g., []int32
+				mfi.merge = func(dst, src pointer) {
+					// NOTE: toInt32Slice is not defined (see pointer_reflect.go).
+					/*
+						sfsp := src.toInt32Slice()
+						if *sfsp != nil {
+							dfsp := dst.toInt32Slice()
+							*dfsp = append(*dfsp, *sfsp...)
+							if *dfsp == nil {
+								*dfsp = []int64{}
+							}
+						}
+					*/
+					sfs := src.getInt32Slice()
+					if sfs != nil {
+						dfs := dst.getInt32Slice()
+						dfs = append(dfs, sfs...)
+						if dfs == nil {
+							dfs = []int32{}
+						}
+						dst.setInt32Slice(dfs)
+					}
+				}
+			case isPointer: // E.g., *int32
+				mfi.merge = func(dst, src pointer) {
+					// NOTE: toInt32Ptr is not defined (see pointer_reflect.go).
+					/*
+						sfpp := src.toInt32Ptr()
+						if *sfpp != nil {
+							dfpp := dst.toInt32Ptr()
+							if *dfpp == nil {
+								*dfpp = Int32(**sfpp)
+							} else {
+								**dfpp = **sfpp
+							}
+						}
+					*/
+					sfp := src.getInt32Ptr()
+					if sfp != nil {
+						dfp := dst.getInt32Ptr()
+						if dfp == nil {
+							dst.setInt32Ptr(*sfp)
+						} else {
+							*dfp = *sfp
+						}
+					}
+				}
+			default: // E.g., int32
+				mfi.merge = func(dst, src pointer) {
+					if v := *src.toInt32(); v != 0 {
+						*dst.toInt32() = v
+					}
+				}
+			}
+		case reflect.Int64:
+			switch {
+			case isSlice: // E.g., []int64
+				mfi.merge = func(dst, src pointer) {
+					sfsp := src.toInt64Slice()
+					if *sfsp != nil {
+						dfsp := dst.toInt64Slice()
+						*dfsp = append(*dfsp, *sfsp...)
+						if *dfsp == nil {
+							*dfsp = []int64{}
+						}
+					}
+				}
+			case isPointer: // E.g., *int64
+				mfi.merge = func(dst, src pointer) {
+					sfpp := src.toInt64Ptr()
+					if *sfpp != nil {
+						dfpp := dst.toInt64Ptr()
+						if *dfpp == nil {
+							*dfpp = Int64(**sfpp)
+						} else {
+							**dfpp = **sfpp
+						}
+					}
+				}
+			default: // E.g., int64
+				mfi.merge = func(dst, src pointer) {
+					if v := *src.toInt64(); v != 0 {
+						*dst.toInt64() = v
+					}
+				}
+			}
+		case reflect.Uint32:
+			switch {
+			case isSlice: // E.g., []uint32
+				mfi.merge = func(dst, src pointer) {
+					sfsp := src.toUint32Slice()
+					if *sfsp != nil {
+						dfsp := dst.toUint32Slice()
+						*dfsp = append(*dfsp, *sfsp...)
+						if *dfsp == nil {
+							*dfsp = []uint32{}
+						}
+					}
+				}
+			case isPointer: // E.g., *uint32
+				mfi.merge = func(dst, src pointer) {
+					sfpp := src.toUint32Ptr()
+					if *sfpp != nil {
+						dfpp := dst.toUint32Ptr()
+						if *dfpp == nil {
+							*dfpp = Uint32(**sfpp)
+						} else {
+							**dfpp = **sfpp
+						}
+					}
+				}
+			default: // E.g., uint32
+				mfi.merge = func(dst, src pointer) {
+					if v := *src.toUint32(); v != 0 {
+						*dst.toUint32() = v
+					}
+				}
+			}
+		case reflect.Uint64:
+			switch {
+			case isSlice: // E.g., []uint64
+				mfi.merge = func(dst, src pointer) {
+					sfsp := src.toUint64Slice()
+					if *sfsp != nil {
+						dfsp := dst.toUint64Slice()
+						*dfsp = append(*dfsp, *sfsp...)
+						if *dfsp == nil {
+							*dfsp = []uint64{}
+						}
+					}
+				}
+			case isPointer: // E.g., *uint64
+				mfi.merge = func(dst, src pointer) {
+					sfpp := src.toUint64Ptr()
+					if *sfpp != nil {
+						dfpp := dst.toUint64Ptr()
+						if *dfpp == nil {
+							*dfpp = Uint64(**sfpp)
+						} else {
+							**dfpp = **sfpp
+						}
+					}
+				}
+			default: // E.g., uint64
+				mfi.merge = func(dst, src pointer) {
+					if v := *src.toUint64(); v != 0 {
+						*dst.toUint64() = v
+					}
+				}
+			}
+		case reflect.Float32:
+			switch {
+			case isSlice: // E.g., []float32
+				mfi.merge = func(dst, src pointer) {
+					sfsp := src.toFloat32Slice()
+					if *sfsp != nil {
+						dfsp := dst.toFloat32Slice()
+						*dfsp = append(*dfsp, *sfsp...)
+						if *dfsp == nil {
+							*dfsp = []float32{}
+						}
+					}
+				}
+			case isPointer: // E.g., *float32
+				mfi.merge = func(dst, src pointer) {
+					sfpp := src.toFloat32Ptr()
+					if *sfpp != nil {
+						dfpp := dst.toFloat32Ptr()
+						if *dfpp == nil {
+							*dfpp = Float32(**sfpp)
+						} else {
+							**dfpp = **sfpp
+						}
+					}
+				}
+			default: // E.g., float32
+				mfi.merge = func(dst, src pointer) {
+					if v := *src.toFloat32(); v != 0 {
+						*dst.toFloat32() = v
+					}
+				}
+			}
+		case reflect.Float64:
+			switch {
+			case isSlice: // E.g., []float64
+				mfi.merge = func(dst, src pointer) {
+					sfsp := src.toFloat64Slice()
+					if *sfsp != nil {
+						dfsp := dst.toFloat64Slice()
+						*dfsp = append(*dfsp, *sfsp...)
+						if *dfsp == nil {
+							*dfsp = []float64{}
+						}
+					}
+				}
+			case isPointer: // E.g., *float64
+				mfi.merge = func(dst, src pointer) {
+					sfpp := src.toFloat64Ptr()
+					if *sfpp != nil {
+						dfpp := dst.toFloat64Ptr()
+						if *dfpp == nil {
+							*dfpp = Float64(**sfpp)
+						} else {
+							**dfpp = **sfpp
+						}
+					}
+				}
+			default: // E.g., float64
+				mfi.merge = func(dst, src pointer) {
+					if v := *src.toFloat64(); v != 0 {
+						*dst.toFloat64() = v
+					}
+				}
+			}
+		case reflect.Bool:
+			switch {
+			case isSlice: // E.g., []bool
+				mfi.merge = func(dst, src pointer) {
+					sfsp := src.toBoolSlice()
+					if *sfsp != nil {
+						dfsp := dst.toBoolSlice()
+						*dfsp = append(*dfsp, *sfsp...)
+						if *dfsp == nil {
+							*dfsp = []bool{}
+						}
+					}
+				}
+			case isPointer: // E.g., *bool
+				mfi.merge = func(dst, src pointer) {
+					sfpp := src.toBoolPtr()
+					if *sfpp != nil {
+						dfpp := dst.toBoolPtr()
+						if *dfpp == nil {
+							*dfpp = Bool(**sfpp)
+						} else {
+							**dfpp = **sfpp
+						}
+					}
+				}
+			default: // E.g., bool
+				mfi.merge = func(dst, src pointer) {
+					if v := *src.toBool(); v {
+						*dst.toBool() = v
+					}
+				}
+			}
+		case reflect.String:
+			switch {
+			case isSlice: // E.g., []string
+				mfi.merge = func(dst, src pointer) {
+					sfsp := src.toStringSlice()
+					if *sfsp != nil {
+						dfsp := dst.toStringSlice()
+						*dfsp = append(*dfsp, *sfsp...)
+						if *dfsp == nil {
+							*dfsp = []string{}
+						}
+					}
+				}
+			case isPointer: // E.g., *string
+				mfi.merge = func(dst, src pointer) {
+					sfpp := src.toStringPtr()
+					if *sfpp != nil {
+						dfpp := dst.toStringPtr()
+						if *dfpp == nil {
+							*dfpp = String(**sfpp)
+						} else {
+							**dfpp = **sfpp
+						}
+					}
+				}
+			default: // E.g., string
+				mfi.merge = func(dst, src pointer) {
+					if v := *src.toString(); v != "" {
+						*dst.toString() = v
+					}
+				}
+			}
+		case reflect.Slice:
+			isProto3 := props.Prop[i].proto3
+			switch {
+			case isPointer:
+				panic("bad pointer in byte slice case in " + tf.Name())
+			case tf.Elem().Kind() != reflect.Uint8:
+				panic("bad element kind in byte slice case in " + tf.Name())
+			case isSlice: // E.g., [][]byte
+				mfi.merge = func(dst, src pointer) {
+					sbsp := src.toBytesSlice()
+					if *sbsp != nil {
+						dbsp := dst.toBytesSlice()
+						for _, sb := range *sbsp {
+							if sb == nil {
+								*dbsp = append(*dbsp, nil)
+							} else {
+								*dbsp = append(*dbsp, append([]byte{}, sb...))
+							}
+						}
+						if *dbsp == nil {
+							*dbsp = [][]byte{}
+						}
+					}
+				}
+			default: // E.g., []byte
+				mfi.merge = func(dst, src pointer) {
+					sbp := src.toBytes()
+					if *sbp != nil {
+						dbp := dst.toBytes()
+						if !isProto3 || len(*sbp) > 0 {
+							*dbp = append([]byte{}, *sbp...)
+						}
+					}
+				}
+			}
+		case reflect.Struct:
+			switch {
+			case !isPointer:
+				panic(fmt.Sprintf("message field %s without pointer", tf))
+			case isSlice: // E.g., []*pb.T
+				mi := getMergeInfo(tf)
+				mfi.merge = func(dst, src pointer) {
+					sps := src.getPointerSlice()
+					if sps != nil {
+						dps := dst.getPointerSlice()
+						for _, sp := range sps {
+							var dp pointer
+							if !sp.isNil() {
+								dp = valToPointer(reflect.New(tf))
+								mi.merge(dp, sp)
+							}
+							dps = append(dps, dp)
+						}
+						if dps == nil {
+							dps = []pointer{}
+						}
+						dst.setPointerSlice(dps)
+					}
+				}
+			default: // E.g., *pb.T
+				mi := getMergeInfo(tf)
+				mfi.merge = func(dst, src pointer) {
+					sp := src.getPointer()
+					if !sp.isNil() {
+						dp := dst.getPointer()
+						if dp.isNil() {
+							dp = valToPointer(reflect.New(tf))
+							dst.setPointer(dp)
+						}
+						mi.merge(dp, sp)
+					}
+				}
+			}
+		case reflect.Map:
+			switch {
+			case isPointer || isSlice:
+				panic("bad pointer or slice in map case in " + tf.Name())
+			default: // E.g., map[K]V
+				mfi.merge = func(dst, src pointer) {
+					sm := src.asPointerTo(tf).Elem()
+					if sm.Len() == 0 {
+						return
+					}
+					dm := dst.asPointerTo(tf).Elem()
+					if dm.IsNil() {
+						dm.Set(reflect.MakeMap(tf))
+					}
+
+					switch tf.Elem().Kind() {
+					case reflect.Ptr: // Proto struct (e.g., *T)
+						for _, key := range sm.MapKeys() {
+							val := sm.MapIndex(key)
+							val = reflect.ValueOf(Clone(val.Interface().(Message)))
+							dm.SetMapIndex(key, val)
+						}
+					case reflect.Slice: // E.g. Bytes type (e.g., []byte)
+						for _, key := range sm.MapKeys() {
+							val := sm.MapIndex(key)
+							val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
+							dm.SetMapIndex(key, val)
+						}
+					default: // Basic type (e.g., string)
+						for _, key := range sm.MapKeys() {
+							val := sm.MapIndex(key)
+							dm.SetMapIndex(key, val)
+						}
+					}
+				}
+			}
+		case reflect.Interface:
+			// Must be oneof field.
+			switch {
+			case isPointer || isSlice:
+				panic("bad pointer or slice in interface case in " + tf.Name())
+			default: // E.g., interface{}
+				// TODO: Make this faster?
+				mfi.merge = func(dst, src pointer) {
+					su := src.asPointerTo(tf).Elem()
+					if !su.IsNil() {
+						du := dst.asPointerTo(tf).Elem()
+						typ := su.Elem().Type()
+						if du.IsNil() || du.Elem().Type() != typ {
+							du.Set(reflect.New(typ.Elem())) // Initialize interface if empty
+						}
+						sv := su.Elem().Elem().Field(0)
+						if sv.Kind() == reflect.Ptr && sv.IsNil() {
+							return
+						}
+						dv := du.Elem().Elem().Field(0)
+						if dv.Kind() == reflect.Ptr && dv.IsNil() {
+							dv.Set(reflect.New(sv.Type().Elem())) // Initialize proto message if empty
+						}
+						switch sv.Type().Kind() {
+						case reflect.Ptr: // Proto struct (e.g., *T)
+							Merge(dv.Interface().(Message), sv.Interface().(Message))
+						case reflect.Slice: // E.g. Bytes type (e.g., []byte)
+							dv.Set(reflect.ValueOf(append([]byte{}, sv.Bytes()...)))
+						default: // Basic type (e.g., string)
+							dv.Set(sv)
+						}
+					}
+				}
+			}
+		default:
+			panic(fmt.Sprintf("merger not found for type:%s", tf))
+		}
+		mi.fields = append(mi.fields, mfi)
+	}
+
+	mi.unrecognized = invalidField
+	if f, ok := t.FieldByName("XXX_unrecognized"); ok {
+		if f.Type != reflect.TypeOf([]byte{}) {
+			panic("expected XXX_unrecognized to be of type []byte")
+		}
+		mi.unrecognized = toField(&f)
+	}
+
+	atomic.StoreInt32(&mi.initialized, 1)
+}
diff --git a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
new file mode 100644
index 0000000..acee2fc
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
@@ -0,0 +1,2053 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"unicode/utf8"
+)
+
+// Unmarshal is the entry point from the generated .pb.go files.
+// This function is not intended to be used by non-generated code.
+// This function is not subject to any compatibility guarantee.
+// msg contains a pointer to a protocol buffer struct.
+// b is the data to be unmarshaled into the protocol buffer.
+// a is a pointer to a place to store cached unmarshal information.
+func (a *InternalMessageInfo) Unmarshal(msg Message, b []byte) error {
+	// Load the unmarshal information for this message type.
+	// The atomic load ensures memory consistency.
+	u := atomicLoadUnmarshalInfo(&a.unmarshal)
+	if u == nil {
+		// Slow path: find unmarshal info for msg, update a with it.
+		u = getUnmarshalInfo(reflect.TypeOf(msg).Elem())
+		atomicStoreUnmarshalInfo(&a.unmarshal, u)
+	}
+	// Then do the unmarshaling.
+	err := u.unmarshal(toPointer(&msg), b)
+	return err
+}
+
+type unmarshalInfo struct {
+	typ reflect.Type // type of the protobuf struct
+
+	// 0 = only typ field is initialized
+	// 1 = completely initialized
+	initialized     int32
+	lock            sync.Mutex                    // prevents double initialization
+	dense           []unmarshalFieldInfo          // fields indexed by tag #
+	sparse          map[uint64]unmarshalFieldInfo // fields indexed by tag #
+	reqFields       []string                      // names of required fields
+	reqMask         uint64                        // 1<<len(reqFields)-1
+	unrecognized    field                         // offset of []byte to put unrecognized data (or invalidField if we should throw it away)
+	extensions      field                         // offset of extensions field (of type proto.XXX_InternalExtensions), or invalidField if it does not exist
+	oldExtensions   field                         // offset of old-form extensions field (of type map[int]Extension)
+	extensionRanges []ExtensionRange              // if non-nil, implies extensions field is valid
+	isMessageSet    bool                          // if true, implies extensions field is valid
+}
+
+// An unmarshaler takes a stream of bytes and a pointer to a field of a message.
+// It decodes the field, stores it at f, and returns the unused bytes.
+// w is the wire encoding.
+// b is the data after the tag and wire encoding have been read.
+type unmarshaler func(b []byte, f pointer, w int) ([]byte, error)
+
+type unmarshalFieldInfo struct {
+	// location of the field in the proto message structure.
+	field field
+
+	// function to unmarshal the data for the field.
+	unmarshal unmarshaler
+
+	// if a required field, contains a single set bit at this field's index in the required field list.
+	reqMask uint64
+
+	name string // name of the field, for error reporting
+}
+
+var (
+	unmarshalInfoMap  = map[reflect.Type]*unmarshalInfo{}
+	unmarshalInfoLock sync.Mutex
+)
+
+// getUnmarshalInfo returns the data structure which can be
+// subsequently used to unmarshal a message of the given type.
+// t is the type of the message (note: not pointer to message).
+func getUnmarshalInfo(t reflect.Type) *unmarshalInfo {
+	// It would be correct to return a new unmarshalInfo
+	// unconditionally. We would end up allocating one
+	// per occurrence of that type as a message or submessage.
+	// We use a cache here just to reduce memory usage.
+	unmarshalInfoLock.Lock()
+	defer unmarshalInfoLock.Unlock()
+	u := unmarshalInfoMap[t]
+	if u == nil {
+		u = &unmarshalInfo{typ: t}
+		// Note: we just set the type here. The rest of the fields
+		// will be initialized on first use.
+		unmarshalInfoMap[t] = u
+	}
+	return u
+}
+
+// unmarshal does the main work of unmarshaling a message.
+// u provides type information used to unmarshal the message.
+// m is a pointer to a protocol buffer message.
+// b is a byte stream to unmarshal into m.
+// This is top routine used when recursively unmarshaling submessages.
+func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {
+	if atomic.LoadInt32(&u.initialized) == 0 {
+		u.computeUnmarshalInfo()
+	}
+	if u.isMessageSet {
+		return unmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
+	}
+	var reqMask uint64 // bitmask of required fields we've seen.
+	var errLater error
+	for len(b) > 0 {
+		// Read tag and wire type.
+		// Special case 1 and 2 byte varints.
+		var x uint64
+		if b[0] < 128 {
+			x = uint64(b[0])
+			b = b[1:]
+		} else if len(b) >= 2 && b[1] < 128 {
+			x = uint64(b[0]&0x7f) + uint64(b[1])<<7
+			b = b[2:]
+		} else {
+			var n int
+			x, n = decodeVarint(b)
+			if n == 0 {
+				return io.ErrUnexpectedEOF
+			}
+			b = b[n:]
+		}
+		tag := x >> 3
+		wire := int(x) & 7
+
+		// Dispatch on the tag to one of the unmarshal* functions below.
+		var f unmarshalFieldInfo
+		if tag < uint64(len(u.dense)) {
+			f = u.dense[tag]
+		} else {
+			f = u.sparse[tag]
+		}
+		if fn := f.unmarshal; fn != nil {
+			var err error
+			b, err = fn(b, m.offset(f.field), wire)
+			if err == nil {
+				reqMask |= f.reqMask
+				continue
+			}
+			if r, ok := err.(*RequiredNotSetError); ok {
+				// Remember this error, but keep parsing. We need to produce
+				// a full parse even if a required field is missing.
+				if errLater == nil {
+					errLater = r
+				}
+				reqMask |= f.reqMask
+				continue
+			}
+			if err != errInternalBadWireType {
+				if err == errInvalidUTF8 {
+					if errLater == nil {
+						fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
+						errLater = &invalidUTF8Error{fullName}
+					}
+					continue
+				}
+				return err
+			}
+			// Fragments with bad wire type are treated as unknown fields.
+		}
+
+		// Unknown tag.
+		if !u.unrecognized.IsValid() {
+			// Don't keep unrecognized data; just skip it.
+			var err error
+			b, err = skipField(b, wire)
+			if err != nil {
+				return err
+			}
+			continue
+		}
+		// Keep unrecognized data around.
+		// maybe in extensions, maybe in the unrecognized field.
+		z := m.offset(u.unrecognized).toBytes()
+		var emap map[int32]Extension
+		var e Extension
+		for _, r := range u.extensionRanges {
+			if uint64(r.Start) <= tag && tag <= uint64(r.End) {
+				if u.extensions.IsValid() {
+					mp := m.offset(u.extensions).toExtensions()
+					emap = mp.extensionsWrite()
+					e = emap[int32(tag)]
+					z = &e.enc
+					break
+				}
+				if u.oldExtensions.IsValid() {
+					p := m.offset(u.oldExtensions).toOldExtensions()
+					emap = *p
+					if emap == nil {
+						emap = map[int32]Extension{}
+						*p = emap
+					}
+					e = emap[int32(tag)]
+					z = &e.enc
+					break
+				}
+				panic("no extensions field available")
+			}
+		}
+
+		// Use wire type to skip data.
+		var err error
+		b0 := b
+		b, err = skipField(b, wire)
+		if err != nil {
+			return err
+		}
+		*z = encodeVarint(*z, tag<<3|uint64(wire))
+		*z = append(*z, b0[:len(b0)-len(b)]...)
+
+		if emap != nil {
+			emap[int32(tag)] = e
+		}
+	}
+	if reqMask != u.reqMask && errLater == nil {
+		// A required field of this message is missing.
+		for _, n := range u.reqFields {
+			if reqMask&1 == 0 {
+				errLater = &RequiredNotSetError{n}
+			}
+			reqMask >>= 1
+		}
+	}
+	return errLater
+}
+
+// computeUnmarshalInfo fills in u with information for use
+// in unmarshaling protocol buffers of type u.typ.
+func (u *unmarshalInfo) computeUnmarshalInfo() {
+	u.lock.Lock()
+	defer u.lock.Unlock()
+	if u.initialized != 0 {
+		return
+	}
+	t := u.typ
+	n := t.NumField()
+
+	// Set up the "not found" value for the unrecognized byte buffer.
+	// This is the default for proto3.
+	u.unrecognized = invalidField
+	u.extensions = invalidField
+	u.oldExtensions = invalidField
+
+	// List of the generated type and offset for each oneof field.
+	type oneofField struct {
+		ityp  reflect.Type // interface type of oneof field
+		field field        // offset in containing message
+	}
+	var oneofFields []oneofField
+
+	for i := 0; i < n; i++ {
+		f := t.Field(i)
+		if f.Name == "XXX_unrecognized" {
+			// The byte slice used to hold unrecognized input is special.
+			if f.Type != reflect.TypeOf(([]byte)(nil)) {
+				panic("bad type for XXX_unrecognized field: " + f.Type.Name())
+			}
+			u.unrecognized = toField(&f)
+			continue
+		}
+		if f.Name == "XXX_InternalExtensions" {
+			// Ditto here.
+			if f.Type != reflect.TypeOf(XXX_InternalExtensions{}) {
+				panic("bad type for XXX_InternalExtensions field: " + f.Type.Name())
+			}
+			u.extensions = toField(&f)
+			if f.Tag.Get("protobuf_messageset") == "1" {
+				u.isMessageSet = true
+			}
+			continue
+		}
+		if f.Name == "XXX_extensions" {
+			// An older form of the extensions field.
+			if f.Type != reflect.TypeOf((map[int32]Extension)(nil)) {
+				panic("bad type for XXX_extensions field: " + f.Type.Name())
+			}
+			u.oldExtensions = toField(&f)
+			continue
+		}
+		if f.Name == "XXX_NoUnkeyedLiteral" || f.Name == "XXX_sizecache" {
+			continue
+		}
+
+		oneof := f.Tag.Get("protobuf_oneof")
+		if oneof != "" {
+			oneofFields = append(oneofFields, oneofField{f.Type, toField(&f)})
+			// The rest of oneof processing happens below.
+			continue
+		}
+
+		tags := f.Tag.Get("protobuf")
+		tagArray := strings.Split(tags, ",")
+		if len(tagArray) < 2 {
+			panic("protobuf tag not enough fields in " + t.Name() + "." + f.Name + ": " + tags)
+		}
+		tag, err := strconv.Atoi(tagArray[1])
+		if err != nil {
+			panic("protobuf tag field not an integer: " + tagArray[1])
+		}
+
+		name := ""
+		for _, tag := range tagArray[3:] {
+			if strings.HasPrefix(tag, "name=") {
+				name = tag[5:]
+			}
+		}
+
+		// Extract unmarshaling function from the field (its type and tags).
+		unmarshal := fieldUnmarshaler(&f)
+
+		// Required field?
+		var reqMask uint64
+		if tagArray[2] == "req" {
+			bit := len(u.reqFields)
+			u.reqFields = append(u.reqFields, name)
+			reqMask = uint64(1) << uint(bit)
+			// TODO: if we have more than 64 required fields, we end up
+			// not verifying that all required fields are present.
+			// Fix this, perhaps using a count of required fields?
+		}
+
+		// Store the info in the correct slot in the message.
+		u.setTag(tag, toField(&f), unmarshal, reqMask, name)
+	}
+
+	// Find any types associated with oneof fields.
+	var oneofImplementers []interface{}
+	switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
+	case oneofFuncsIface:
+		_, _, _, oneofImplementers = m.XXX_OneofFuncs()
+	case oneofWrappersIface:
+		oneofImplementers = m.XXX_OneofWrappers()
+	}
+	for _, v := range oneofImplementers {
+		tptr := reflect.TypeOf(v) // *Msg_X
+		typ := tptr.Elem()        // Msg_X
+
+		f := typ.Field(0) // oneof implementers have one field
+		baseUnmarshal := fieldUnmarshaler(&f)
+		tags := strings.Split(f.Tag.Get("protobuf"), ",")
+		fieldNum, err := strconv.Atoi(tags[1])
+		if err != nil {
+			panic("protobuf tag field not an integer: " + tags[1])
+		}
+		var name string
+		for _, tag := range tags {
+			if strings.HasPrefix(tag, "name=") {
+				name = strings.TrimPrefix(tag, "name=")
+				break
+			}
+		}
+
+		// Find the oneof field that this struct implements.
+		// Might take O(n^2) to process all of the oneofs, but who cares.
+		for _, of := range oneofFields {
+			if tptr.Implements(of.ityp) {
+				// We have found the corresponding interface for this struct.
+				// That lets us know where this struct should be stored
+				// when we encounter it during unmarshaling.
+				unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
+				u.setTag(fieldNum, of.field, unmarshal, 0, name)
+			}
+		}
+
+	}
+
+	// Get extension ranges, if any.
+	fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
+	if fn.IsValid() {
+		if !u.extensions.IsValid() && !u.oldExtensions.IsValid() {
+			panic("a message with extensions, but no extensions field in " + t.Name())
+		}
+		u.extensionRanges = fn.Call(nil)[0].Interface().([]ExtensionRange)
+	}
+
+	// Explicitly disallow tag 0. This will ensure we flag an error
+	// when decoding a buffer of all zeros. Without this code, we
+	// would decode and skip an all-zero buffer of even length.
+	// [0 0] is [tag=0/wiretype=varint varint-encoded-0].
+	u.setTag(0, zeroField, func(b []byte, f pointer, w int) ([]byte, error) {
+		return nil, fmt.Errorf("proto: %s: illegal tag 0 (wire type %d)", t, w)
+	}, 0, "")
+
+	// Set mask for required field check.
+	u.reqMask = uint64(1)<<uint(len(u.reqFields)) - 1
+
+	atomic.StoreInt32(&u.initialized, 1)
+}
+
+// setTag stores the unmarshal information for the given tag.
+// tag = tag # for field
+// field/unmarshal = unmarshal info for that field.
+// reqMask = if required, bitmask for field position in required field list. 0 otherwise.
+// name = short name of the field.
+func (u *unmarshalInfo) setTag(tag int, field field, unmarshal unmarshaler, reqMask uint64, name string) {
+	i := unmarshalFieldInfo{field: field, unmarshal: unmarshal, reqMask: reqMask, name: name}
+	n := u.typ.NumField()
+	if tag >= 0 && (tag < 16 || tag < 2*n) { // TODO: what are the right numbers here?
+		for len(u.dense) <= tag {
+			u.dense = append(u.dense, unmarshalFieldInfo{})
+		}
+		u.dense[tag] = i
+		return
+	}
+	if u.sparse == nil {
+		u.sparse = map[uint64]unmarshalFieldInfo{}
+	}
+	u.sparse[uint64(tag)] = i
+}
+
+// fieldUnmarshaler returns an unmarshaler for the given field.
+func fieldUnmarshaler(f *reflect.StructField) unmarshaler {
+	if f.Type.Kind() == reflect.Map {
+		return makeUnmarshalMap(f)
+	}
+	return typeUnmarshaler(f.Type, f.Tag.Get("protobuf"))
+}
+
+// typeUnmarshaler returns an unmarshaler for the given field type / field tag pair.
+func typeUnmarshaler(t reflect.Type, tags string) unmarshaler {
+	tagArray := strings.Split(tags, ",")
+	encoding := tagArray[0]
+	name := "unknown"
+	proto3 := false
+	validateUTF8 := true
+	for _, tag := range tagArray[3:] {
+		if strings.HasPrefix(tag, "name=") {
+			name = tag[5:]
+		}
+		if tag == "proto3" {
+			proto3 = true
+		}
+	}
+	validateUTF8 = validateUTF8 && proto3
+
+	// Figure out packaging (pointer, slice, or both)
+	slice := false
+	pointer := false
+	if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
+		slice = true
+		t = t.Elem()
+	}
+	if t.Kind() == reflect.Ptr {
+		pointer = true
+		t = t.Elem()
+	}
+
+	// We'll never have both pointer and slice for basic types.
+	if pointer && slice && t.Kind() != reflect.Struct {
+		panic("both pointer and slice for basic type in " + t.Name())
+	}
+
+	switch t.Kind() {
+	case reflect.Bool:
+		if pointer {
+			return unmarshalBoolPtr
+		}
+		if slice {
+			return unmarshalBoolSlice
+		}
+		return unmarshalBoolValue
+	case reflect.Int32:
+		switch encoding {
+		case "fixed32":
+			if pointer {
+				return unmarshalFixedS32Ptr
+			}
+			if slice {
+				return unmarshalFixedS32Slice
+			}
+			return unmarshalFixedS32Value
+		case "varint":
+			// this could be int32 or enum
+			if pointer {
+				return unmarshalInt32Ptr
+			}
+			if slice {
+				return unmarshalInt32Slice
+			}
+			return unmarshalInt32Value
+		case "zigzag32":
+			if pointer {
+				return unmarshalSint32Ptr
+			}
+			if slice {
+				return unmarshalSint32Slice
+			}
+			return unmarshalSint32Value
+		}
+	case reflect.Int64:
+		switch encoding {
+		case "fixed64":
+			if pointer {
+				return unmarshalFixedS64Ptr
+			}
+			if slice {
+				return unmarshalFixedS64Slice
+			}
+			return unmarshalFixedS64Value
+		case "varint":
+			if pointer {
+				return unmarshalInt64Ptr
+			}
+			if slice {
+				return unmarshalInt64Slice
+			}
+			return unmarshalInt64Value
+		case "zigzag64":
+			if pointer {
+				return unmarshalSint64Ptr
+			}
+			if slice {
+				return unmarshalSint64Slice
+			}
+			return unmarshalSint64Value
+		}
+	case reflect.Uint32:
+		switch encoding {
+		case "fixed32":
+			if pointer {
+				return unmarshalFixed32Ptr
+			}
+			if slice {
+				return unmarshalFixed32Slice
+			}
+			return unmarshalFixed32Value
+		case "varint":
+			if pointer {
+				return unmarshalUint32Ptr
+			}
+			if slice {
+				return unmarshalUint32Slice
+			}
+			return unmarshalUint32Value
+		}
+	case reflect.Uint64:
+		switch encoding {
+		case "fixed64":
+			if pointer {
+				return unmarshalFixed64Ptr
+			}
+			if slice {
+				return unmarshalFixed64Slice
+			}
+			return unmarshalFixed64Value
+		case "varint":
+			if pointer {
+				return unmarshalUint64Ptr
+			}
+			if slice {
+				return unmarshalUint64Slice
+			}
+			return unmarshalUint64Value
+		}
+	case reflect.Float32:
+		if pointer {
+			return unmarshalFloat32Ptr
+		}
+		if slice {
+			return unmarshalFloat32Slice
+		}
+		return unmarshalFloat32Value
+	case reflect.Float64:
+		if pointer {
+			return unmarshalFloat64Ptr
+		}
+		if slice {
+			return unmarshalFloat64Slice
+		}
+		return unmarshalFloat64Value
+	case reflect.Map:
+		panic("map type in typeUnmarshaler in " + t.Name())
+	case reflect.Slice:
+		if pointer {
+			panic("bad pointer in slice case in " + t.Name())
+		}
+		if slice {
+			return unmarshalBytesSlice
+		}
+		return unmarshalBytesValue
+	case reflect.String:
+		if validateUTF8 {
+			if pointer {
+				return unmarshalUTF8StringPtr
+			}
+			if slice {
+				return unmarshalUTF8StringSlice
+			}
+			return unmarshalUTF8StringValue
+		}
+		if pointer {
+			return unmarshalStringPtr
+		}
+		if slice {
+			return unmarshalStringSlice
+		}
+		return unmarshalStringValue
+	case reflect.Struct:
+		// message or group field
+		if !pointer {
+			panic(fmt.Sprintf("message/group field %s:%s without pointer", t, encoding))
+		}
+		switch encoding {
+		case "bytes":
+			if slice {
+				return makeUnmarshalMessageSlicePtr(getUnmarshalInfo(t), name)
+			}
+			return makeUnmarshalMessagePtr(getUnmarshalInfo(t), name)
+		case "group":
+			if slice {
+				return makeUnmarshalGroupSlicePtr(getUnmarshalInfo(t), name)
+			}
+			return makeUnmarshalGroupPtr(getUnmarshalInfo(t), name)
+		}
+	}
+	panic(fmt.Sprintf("unmarshaler not found type:%s encoding:%s", t, encoding))
+}
+
+// Below are all the unmarshalers for individual fields of various types.
+
+func unmarshalInt64Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int64(x)
+	*f.toInt64() = v
+	return b, nil
+}
+
+func unmarshalInt64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int64(x)
+	*f.toInt64Ptr() = &v
+	return b, nil
+}
+
+func unmarshalInt64Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			x, n = decodeVarint(b)
+			if n == 0 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			b = b[n:]
+			v := int64(x)
+			s := f.toInt64Slice()
+			*s = append(*s, v)
+		}
+		return res, nil
+	}
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int64(x)
+	s := f.toInt64Slice()
+	*s = append(*s, v)
+	return b, nil
+}
+
+func unmarshalSint64Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int64(x>>1) ^ int64(x)<<63>>63
+	*f.toInt64() = v
+	return b, nil
+}
+
+func unmarshalSint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int64(x>>1) ^ int64(x)<<63>>63
+	*f.toInt64Ptr() = &v
+	return b, nil
+}
+
+func unmarshalSint64Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			x, n = decodeVarint(b)
+			if n == 0 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			b = b[n:]
+			v := int64(x>>1) ^ int64(x)<<63>>63
+			s := f.toInt64Slice()
+			*s = append(*s, v)
+		}
+		return res, nil
+	}
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int64(x>>1) ^ int64(x)<<63>>63
+	s := f.toInt64Slice()
+	*s = append(*s, v)
+	return b, nil
+}
+
+func unmarshalUint64Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := uint64(x)
+	*f.toUint64() = v
+	return b, nil
+}
+
+func unmarshalUint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := uint64(x)
+	*f.toUint64Ptr() = &v
+	return b, nil
+}
+
+func unmarshalUint64Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			x, n = decodeVarint(b)
+			if n == 0 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			b = b[n:]
+			v := uint64(x)
+			s := f.toUint64Slice()
+			*s = append(*s, v)
+		}
+		return res, nil
+	}
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := uint64(x)
+	s := f.toUint64Slice()
+	*s = append(*s, v)
+	return b, nil
+}
+
+func unmarshalInt32Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int32(x)
+	*f.toInt32() = v
+	return b, nil
+}
+
+func unmarshalInt32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int32(x)
+	f.setInt32Ptr(v)
+	return b, nil
+}
+
+func unmarshalInt32Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			x, n = decodeVarint(b)
+			if n == 0 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			b = b[n:]
+			v := int32(x)
+			f.appendInt32Slice(v)
+		}
+		return res, nil
+	}
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int32(x)
+	f.appendInt32Slice(v)
+	return b, nil
+}
+
+func unmarshalSint32Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int32(x>>1) ^ int32(x)<<31>>31
+	*f.toInt32() = v
+	return b, nil
+}
+
+func unmarshalSint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int32(x>>1) ^ int32(x)<<31>>31
+	f.setInt32Ptr(v)
+	return b, nil
+}
+
+func unmarshalSint32Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			x, n = decodeVarint(b)
+			if n == 0 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			b = b[n:]
+			v := int32(x>>1) ^ int32(x)<<31>>31
+			f.appendInt32Slice(v)
+		}
+		return res, nil
+	}
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := int32(x>>1) ^ int32(x)<<31>>31
+	f.appendInt32Slice(v)
+	return b, nil
+}
+
+func unmarshalUint32Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := uint32(x)
+	*f.toUint32() = v
+	return b, nil
+}
+
+func unmarshalUint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := uint32(x)
+	*f.toUint32Ptr() = &v
+	return b, nil
+}
+
+func unmarshalUint32Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			x, n = decodeVarint(b)
+			if n == 0 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			b = b[n:]
+			v := uint32(x)
+			s := f.toUint32Slice()
+			*s = append(*s, v)
+		}
+		return res, nil
+	}
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	v := uint32(x)
+	s := f.toUint32Slice()
+	*s = append(*s, v)
+	return b, nil
+}
+
+func unmarshalFixed64Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed64 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 8 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+	*f.toUint64() = v
+	return b[8:], nil
+}
+
+func unmarshalFixed64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed64 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 8 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+	*f.toUint64Ptr() = &v
+	return b[8:], nil
+}
+
+func unmarshalFixed64Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			if len(b) < 8 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+			s := f.toUint64Slice()
+			*s = append(*s, v)
+			b = b[8:]
+		}
+		return res, nil
+	}
+	if w != WireFixed64 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 8 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+	s := f.toUint64Slice()
+	*s = append(*s, v)
+	return b[8:], nil
+}
+
+func unmarshalFixedS64Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed64 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 8 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+	*f.toInt64() = v
+	return b[8:], nil
+}
+
+func unmarshalFixedS64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed64 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 8 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+	*f.toInt64Ptr() = &v
+	return b[8:], nil
+}
+
+func unmarshalFixedS64Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			if len(b) < 8 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+			s := f.toInt64Slice()
+			*s = append(*s, v)
+			b = b[8:]
+		}
+		return res, nil
+	}
+	if w != WireFixed64 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 8 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
+	s := f.toInt64Slice()
+	*s = append(*s, v)
+	return b[8:], nil
+}
+
+func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed32 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 4 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+	*f.toUint32() = v
+	return b[4:], nil
+}
+
+func unmarshalFixed32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed32 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 4 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+	*f.toUint32Ptr() = &v
+	return b[4:], nil
+}
+
+func unmarshalFixed32Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			if len(b) < 4 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+			s := f.toUint32Slice()
+			*s = append(*s, v)
+			b = b[4:]
+		}
+		return res, nil
+	}
+	if w != WireFixed32 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 4 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
+	s := f.toUint32Slice()
+	*s = append(*s, v)
+	return b[4:], nil
+}
+
+func unmarshalFixedS32Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed32 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 4 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+	*f.toInt32() = v
+	return b[4:], nil
+}
+
+func unmarshalFixedS32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed32 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 4 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+	f.setInt32Ptr(v)
+	return b[4:], nil
+}
+
+func unmarshalFixedS32Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			if len(b) < 4 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+			f.appendInt32Slice(v)
+			b = b[4:]
+		}
+		return res, nil
+	}
+	if w != WireFixed32 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 4 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
+	f.appendInt32Slice(v)
+	return b[4:], nil
+}
+
+func unmarshalBoolValue(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	// Note: any length varint is allowed, even though any sane
+	// encoder will use one byte.
+	// See https://github.com/golang/protobuf/issues/76
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	// TODO: check if x>1? Tests seem to indicate no.
+	v := x != 0
+	*f.toBool() = v
+	return b[n:], nil
+}
+
+func unmarshalBoolPtr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := x != 0
+	*f.toBoolPtr() = &v
+	return b[n:], nil
+}
+
+func unmarshalBoolSlice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			x, n = decodeVarint(b)
+			if n == 0 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			v := x != 0
+			s := f.toBoolSlice()
+			*s = append(*s, v)
+			b = b[n:]
+		}
+		return res, nil
+	}
+	if w != WireVarint {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := x != 0
+	s := f.toBoolSlice()
+	*s = append(*s, v)
+	return b[n:], nil
+}
+
+func unmarshalFloat64Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed64 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 8 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+	*f.toFloat64() = v
+	return b[8:], nil
+}
+
+func unmarshalFloat64Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed64 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 8 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+	*f.toFloat64Ptr() = &v
+	return b[8:], nil
+}
+
+func unmarshalFloat64Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			if len(b) < 8 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+			s := f.toFloat64Slice()
+			*s = append(*s, v)
+			b = b[8:]
+		}
+		return res, nil
+	}
+	if w != WireFixed64 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 8 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
+	s := f.toFloat64Slice()
+	*s = append(*s, v)
+	return b[8:], nil
+}
+
+func unmarshalFloat32Value(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed32 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 4 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+	*f.toFloat32() = v
+	return b[4:], nil
+}
+
+func unmarshalFloat32Ptr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireFixed32 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 4 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+	*f.toFloat32Ptr() = &v
+	return b[4:], nil
+}
+
+func unmarshalFloat32Slice(b []byte, f pointer, w int) ([]byte, error) {
+	if w == WireBytes { // packed
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		res := b[x:]
+		b = b[:x]
+		for len(b) > 0 {
+			if len(b) < 4 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+			s := f.toFloat32Slice()
+			*s = append(*s, v)
+			b = b[4:]
+		}
+		return res, nil
+	}
+	if w != WireFixed32 {
+		return b, errInternalBadWireType
+	}
+	if len(b) < 4 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
+	s := f.toFloat32Slice()
+	*s = append(*s, v)
+	return b[4:], nil
+}
+
+func unmarshalStringValue(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireBytes {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	if x > uint64(len(b)) {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := string(b[:x])
+	*f.toString() = v
+	return b[x:], nil
+}
+
+func unmarshalStringPtr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireBytes {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	if x > uint64(len(b)) {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := string(b[:x])
+	*f.toStringPtr() = &v
+	return b[x:], nil
+}
+
+func unmarshalStringSlice(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireBytes {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	if x > uint64(len(b)) {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := string(b[:x])
+	s := f.toStringSlice()
+	*s = append(*s, v)
+	return b[x:], nil
+}
+
+func unmarshalUTF8StringValue(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireBytes {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	if x > uint64(len(b)) {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := string(b[:x])
+	*f.toString() = v
+	if !utf8.ValidString(v) {
+		return b[x:], errInvalidUTF8
+	}
+	return b[x:], nil
+}
+
+func unmarshalUTF8StringPtr(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireBytes {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	if x > uint64(len(b)) {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := string(b[:x])
+	*f.toStringPtr() = &v
+	if !utf8.ValidString(v) {
+		return b[x:], errInvalidUTF8
+	}
+	return b[x:], nil
+}
+
+func unmarshalUTF8StringSlice(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireBytes {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	if x > uint64(len(b)) {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := string(b[:x])
+	s := f.toStringSlice()
+	*s = append(*s, v)
+	if !utf8.ValidString(v) {
+		return b[x:], errInvalidUTF8
+	}
+	return b[x:], nil
+}
+
+var emptyBuf [0]byte
+
+func unmarshalBytesValue(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireBytes {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	if x > uint64(len(b)) {
+		return nil, io.ErrUnexpectedEOF
+	}
+	// The use of append here is a trick which avoids the zeroing
+	// that would be required if we used a make/copy pair.
+	// We append to emptyBuf instead of nil because we want
+	// a non-nil result even when the length is 0.
+	v := append(emptyBuf[:], b[:x]...)
+	*f.toBytes() = v
+	return b[x:], nil
+}
+
+func unmarshalBytesSlice(b []byte, f pointer, w int) ([]byte, error) {
+	if w != WireBytes {
+		return b, errInternalBadWireType
+	}
+	x, n := decodeVarint(b)
+	if n == 0 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	b = b[n:]
+	if x > uint64(len(b)) {
+		return nil, io.ErrUnexpectedEOF
+	}
+	v := append(emptyBuf[:], b[:x]...)
+	s := f.toBytesSlice()
+	*s = append(*s, v)
+	return b[x:], nil
+}
+
+func makeUnmarshalMessagePtr(sub *unmarshalInfo, name string) unmarshaler {
+	return func(b []byte, f pointer, w int) ([]byte, error) {
+		if w != WireBytes {
+			return b, errInternalBadWireType
+		}
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		// First read the message field to see if something is there.
+		// The semantics of multiple submessages are weird.  Instead of
+		// the last one winning (as it is for all other fields), multiple
+		// submessages are merged.
+		v := f.getPointer()
+		if v.isNil() {
+			v = valToPointer(reflect.New(sub.typ))
+			f.setPointer(v)
+		}
+		err := sub.unmarshal(v, b[:x])
+		if err != nil {
+			if r, ok := err.(*RequiredNotSetError); ok {
+				r.field = name + "." + r.field
+			} else {
+				return nil, err
+			}
+		}
+		return b[x:], err
+	}
+}
+
+func makeUnmarshalMessageSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
+	return func(b []byte, f pointer, w int) ([]byte, error) {
+		if w != WireBytes {
+			return b, errInternalBadWireType
+		}
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		v := valToPointer(reflect.New(sub.typ))
+		err := sub.unmarshal(v, b[:x])
+		if err != nil {
+			if r, ok := err.(*RequiredNotSetError); ok {
+				r.field = name + "." + r.field
+			} else {
+				return nil, err
+			}
+		}
+		f.appendPointer(v)
+		return b[x:], err
+	}
+}
+
+func makeUnmarshalGroupPtr(sub *unmarshalInfo, name string) unmarshaler {
+	return func(b []byte, f pointer, w int) ([]byte, error) {
+		if w != WireStartGroup {
+			return b, errInternalBadWireType
+		}
+		x, y := findEndGroup(b)
+		if x < 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		v := f.getPointer()
+		if v.isNil() {
+			v = valToPointer(reflect.New(sub.typ))
+			f.setPointer(v)
+		}
+		err := sub.unmarshal(v, b[:x])
+		if err != nil {
+			if r, ok := err.(*RequiredNotSetError); ok {
+				r.field = name + "." + r.field
+			} else {
+				return nil, err
+			}
+		}
+		return b[y:], err
+	}
+}
+
+func makeUnmarshalGroupSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
+	return func(b []byte, f pointer, w int) ([]byte, error) {
+		if w != WireStartGroup {
+			return b, errInternalBadWireType
+		}
+		x, y := findEndGroup(b)
+		if x < 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		v := valToPointer(reflect.New(sub.typ))
+		err := sub.unmarshal(v, b[:x])
+		if err != nil {
+			if r, ok := err.(*RequiredNotSetError); ok {
+				r.field = name + "." + r.field
+			} else {
+				return nil, err
+			}
+		}
+		f.appendPointer(v)
+		return b[y:], err
+	}
+}
+
+func makeUnmarshalMap(f *reflect.StructField) unmarshaler {
+	t := f.Type
+	kt := t.Key()
+	vt := t.Elem()
+	unmarshalKey := typeUnmarshaler(kt, f.Tag.Get("protobuf_key"))
+	unmarshalVal := typeUnmarshaler(vt, f.Tag.Get("protobuf_val"))
+	return func(b []byte, f pointer, w int) ([]byte, error) {
+		// The map entry is a submessage. Figure out how big it is.
+		if w != WireBytes {
+			return nil, fmt.Errorf("proto: bad wiretype for map field: got %d want %d", w, WireBytes)
+		}
+		x, n := decodeVarint(b)
+		if n == 0 {
+			return nil, io.ErrUnexpectedEOF
+		}
+		b = b[n:]
+		if x > uint64(len(b)) {
+			return nil, io.ErrUnexpectedEOF
+		}
+		r := b[x:] // unused data to return
+		b = b[:x]  // data for map entry
+
+		// Note: we could use #keys * #values ~= 200 functions
+		// to do map decoding without reflection. Probably not worth it.
+		// Maps will be somewhat slow. Oh well.
+
+		// Read key and value from data.
+		var nerr nonFatal
+		k := reflect.New(kt)
+		v := reflect.New(vt)
+		for len(b) > 0 {
+			x, n := decodeVarint(b)
+			if n == 0 {
+				return nil, io.ErrUnexpectedEOF
+			}
+			wire := int(x) & 7
+			b = b[n:]
+
+			var err error
+			switch x >> 3 {
+			case 1:
+				b, err = unmarshalKey(b, valToPointer(k), wire)
+			case 2:
+				b, err = unmarshalVal(b, valToPointer(v), wire)
+			default:
+				err = errInternalBadWireType // skip unknown tag
+			}
+
+			if nerr.Merge(err) {
+				continue
+			}
+			if err != errInternalBadWireType {
+				return nil, err
+			}
+
+			// Skip past unknown fields.
+			b, err = skipField(b, wire)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		// Get map, allocate if needed.
+		m := f.asPointerTo(t).Elem() // an addressable map[K]T
+		if m.IsNil() {
+			m.Set(reflect.MakeMap(t))
+		}
+
+		// Insert into map.
+		m.SetMapIndex(k.Elem(), v.Elem())
+
+		return r, nerr.E
+	}
+}
+
+// makeUnmarshalOneof makes an unmarshaler for oneof fields.
+// for:
+// message Msg {
+//   oneof F {
+//     int64 X = 1;
+//     float64 Y = 2;
+//   }
+// }
+// typ is the type of the concrete entry for a oneof case (e.g. Msg_X).
+// ityp is the interface type of the oneof field (e.g. isMsg_F).
+// unmarshal is the unmarshaler for the base type of the oneof case (e.g. int64).
+// Note that this function will be called once for each case in the oneof.
+func makeUnmarshalOneof(typ, ityp reflect.Type, unmarshal unmarshaler) unmarshaler {
+	sf := typ.Field(0)
+	field0 := toField(&sf)
+	return func(b []byte, f pointer, w int) ([]byte, error) {
+		// Allocate holder for value.
+		v := reflect.New(typ)
+
+		// Unmarshal data into holder.
+		// We unmarshal into the first field of the holder object.
+		var err error
+		var nerr nonFatal
+		b, err = unmarshal(b, valToPointer(v).offset(field0), w)
+		if !nerr.Merge(err) {
+			return nil, err
+		}
+
+		// Write pointer to holder into target field.
+		f.asPointerTo(ityp).Elem().Set(v)
+
+		return b, nerr.E
+	}
+}
+
+// Error used by decode internally.
+var errInternalBadWireType = errors.New("proto: internal error: bad wiretype")
+
+// skipField skips past a field of type wire and returns the remaining bytes.
+func skipField(b []byte, wire int) ([]byte, error) {
+	switch wire {
+	case WireVarint:
+		_, k := decodeVarint(b)
+		if k == 0 {
+			return b, io.ErrUnexpectedEOF
+		}
+		b = b[k:]
+	case WireFixed32:
+		if len(b) < 4 {
+			return b, io.ErrUnexpectedEOF
+		}
+		b = b[4:]
+	case WireFixed64:
+		if len(b) < 8 {
+			return b, io.ErrUnexpectedEOF
+		}
+		b = b[8:]
+	case WireBytes:
+		m, k := decodeVarint(b)
+		if k == 0 || uint64(len(b)-k) < m {
+			return b, io.ErrUnexpectedEOF
+		}
+		b = b[uint64(k)+m:]
+	case WireStartGroup:
+		_, i := findEndGroup(b)
+		if i == -1 {
+			return b, io.ErrUnexpectedEOF
+		}
+		b = b[i:]
+	default:
+		return b, fmt.Errorf("proto: can't skip unknown wire type %d", wire)
+	}
+	return b, nil
+}
+
+// findEndGroup finds the index of the next EndGroup tag.
+// Groups may be nested, so the "next" EndGroup tag is the first
+// unpaired EndGroup.
+// findEndGroup returns the indexes of the start and end of the EndGroup tag.
+// Returns (-1,-1) if it can't find one.
+func findEndGroup(b []byte) (int, int) {
+	depth := 1
+	i := 0
+	for {
+		x, n := decodeVarint(b[i:])
+		if n == 0 {
+			return -1, -1
+		}
+		j := i
+		i += n
+		switch x & 7 {
+		case WireVarint:
+			_, k := decodeVarint(b[i:])
+			if k == 0 {
+				return -1, -1
+			}
+			i += k
+		case WireFixed32:
+			if len(b)-4 < i {
+				return -1, -1
+			}
+			i += 4
+		case WireFixed64:
+			if len(b)-8 < i {
+				return -1, -1
+			}
+			i += 8
+		case WireBytes:
+			m, k := decodeVarint(b[i:])
+			if k == 0 {
+				return -1, -1
+			}
+			i += k
+			if uint64(len(b)-i) < m {
+				return -1, -1
+			}
+			i += int(m)
+		case WireStartGroup:
+			depth++
+		case WireEndGroup:
+			depth--
+			if depth == 0 {
+				return j, i
+			}
+		default:
+			return -1, -1
+		}
+	}
+}
+
+// encodeVarint appends a varint-encoded integer to b and returns the result.
+func encodeVarint(b []byte, x uint64) []byte {
+	for x >= 1<<7 {
+		b = append(b, byte(x&0x7f|0x80))
+		x >>= 7
+	}
+	return append(b, byte(x))
+}
+
+// decodeVarint reads a varint-encoded integer from b.
+// Returns the decoded integer and the number of bytes read.
+// If there is an error, it returns 0,0.
+func decodeVarint(b []byte) (uint64, int) {
+	var x, y uint64
+	if len(b) == 0 {
+		goto bad
+	}
+	x = uint64(b[0])
+	if x < 0x80 {
+		return x, 1
+	}
+	x -= 0x80
+
+	if len(b) <= 1 {
+		goto bad
+	}
+	y = uint64(b[1])
+	x += y << 7
+	if y < 0x80 {
+		return x, 2
+	}
+	x -= 0x80 << 7
+
+	if len(b) <= 2 {
+		goto bad
+	}
+	y = uint64(b[2])
+	x += y << 14
+	if y < 0x80 {
+		return x, 3
+	}
+	x -= 0x80 << 14
+
+	if len(b) <= 3 {
+		goto bad
+	}
+	y = uint64(b[3])
+	x += y << 21
+	if y < 0x80 {
+		return x, 4
+	}
+	x -= 0x80 << 21
+
+	if len(b) <= 4 {
+		goto bad
+	}
+	y = uint64(b[4])
+	x += y << 28
+	if y < 0x80 {
+		return x, 5
+	}
+	x -= 0x80 << 28
+
+	if len(b) <= 5 {
+		goto bad
+	}
+	y = uint64(b[5])
+	x += y << 35
+	if y < 0x80 {
+		return x, 6
+	}
+	x -= 0x80 << 35
+
+	if len(b) <= 6 {
+		goto bad
+	}
+	y = uint64(b[6])
+	x += y << 42
+	if y < 0x80 {
+		return x, 7
+	}
+	x -= 0x80 << 42
+
+	if len(b) <= 7 {
+		goto bad
+	}
+	y = uint64(b[7])
+	x += y << 49
+	if y < 0x80 {
+		return x, 8
+	}
+	x -= 0x80 << 49
+
+	if len(b) <= 8 {
+		goto bad
+	}
+	y = uint64(b[8])
+	x += y << 56
+	if y < 0x80 {
+		return x, 9
+	}
+	x -= 0x80 << 56
+
+	if len(b) <= 9 {
+		goto bad
+	}
+	y = uint64(b[9])
+	x += y << 63
+	if y < 2 {
+		return x, 10
+	}
+
+bad:
+	return 0, 0
+}
diff --git a/vendor/github.com/golang/protobuf/proto/text.go b/vendor/github.com/golang/protobuf/proto/text.go
new file mode 100644
index 0000000..1aaee72
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/text.go
@@ -0,0 +1,843 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// Functions for writing the text protocol buffer format.
+
+import (
+	"bufio"
+	"bytes"
+	"encoding"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"math"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+var (
+	newline         = []byte("\n")
+	spaces          = []byte("                                        ")
+	endBraceNewline = []byte("}\n")
+	backslashN      = []byte{'\\', 'n'}
+	backslashR      = []byte{'\\', 'r'}
+	backslashT      = []byte{'\\', 't'}
+	backslashDQ     = []byte{'\\', '"'}
+	backslashBS     = []byte{'\\', '\\'}
+	posInf          = []byte("inf")
+	negInf          = []byte("-inf")
+	nan             = []byte("nan")
+)
+
+type writer interface {
+	io.Writer
+	WriteByte(byte) error
+}
+
+// textWriter is an io.Writer that tracks its indentation level.
+type textWriter struct {
+	ind      int
+	complete bool // if the current position is a complete line
+	compact  bool // whether to write out as a one-liner
+	w        writer
+}
+
+func (w *textWriter) WriteString(s string) (n int, err error) {
+	if !strings.Contains(s, "\n") {
+		if !w.compact && w.complete {
+			w.writeIndent()
+		}
+		w.complete = false
+		return io.WriteString(w.w, s)
+	}
+	// WriteString is typically called without newlines, so this
+	// codepath and its copy are rare.  We copy to avoid
+	// duplicating all of Write's logic here.
+	return w.Write([]byte(s))
+}
+
+func (w *textWriter) Write(p []byte) (n int, err error) {
+	newlines := bytes.Count(p, newline)
+	if newlines == 0 {
+		if !w.compact && w.complete {
+			w.writeIndent()
+		}
+		n, err = w.w.Write(p)
+		w.complete = false
+		return n, err
+	}
+
+	frags := bytes.SplitN(p, newline, newlines+1)
+	if w.compact {
+		for i, frag := range frags {
+			if i > 0 {
+				if err := w.w.WriteByte(' '); err != nil {
+					return n, err
+				}
+				n++
+			}
+			nn, err := w.w.Write(frag)
+			n += nn
+			if err != nil {
+				return n, err
+			}
+		}
+		return n, nil
+	}
+
+	for i, frag := range frags {
+		if w.complete {
+			w.writeIndent()
+		}
+		nn, err := w.w.Write(frag)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+		if i+1 < len(frags) {
+			if err := w.w.WriteByte('\n'); err != nil {
+				return n, err
+			}
+			n++
+		}
+	}
+	w.complete = len(frags[len(frags)-1]) == 0
+	return n, nil
+}
+
+func (w *textWriter) WriteByte(c byte) error {
+	if w.compact && c == '\n' {
+		c = ' '
+	}
+	if !w.compact && w.complete {
+		w.writeIndent()
+	}
+	err := w.w.WriteByte(c)
+	w.complete = c == '\n'
+	return err
+}
+
+func (w *textWriter) indent() { w.ind++ }
+
+func (w *textWriter) unindent() {
+	if w.ind == 0 {
+		log.Print("proto: textWriter unindented too far")
+		return
+	}
+	w.ind--
+}
+
+func writeName(w *textWriter, props *Properties) error {
+	if _, err := w.WriteString(props.OrigName); err != nil {
+		return err
+	}
+	if props.Wire != "group" {
+		return w.WriteByte(':')
+	}
+	return nil
+}
+
+func requiresQuotes(u string) bool {
+	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
+	for _, ch := range u {
+		switch {
+		case ch == '.' || ch == '/' || ch == '_':
+			continue
+		case '0' <= ch && ch <= '9':
+			continue
+		case 'A' <= ch && ch <= 'Z':
+			continue
+		case 'a' <= ch && ch <= 'z':
+			continue
+		default:
+			return true
+		}
+	}
+	return false
+}
+
+// isAny reports whether sv is a google.protobuf.Any message
+func isAny(sv reflect.Value) bool {
+	type wkt interface {
+		XXX_WellKnownType() string
+	}
+	t, ok := sv.Addr().Interface().(wkt)
+	return ok && t.XXX_WellKnownType() == "Any"
+}
+
+// writeProto3Any writes an expanded google.protobuf.Any message.
+//
+// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
+// required messages are not linked in).
+//
+// It returns (true, error) when sv was written in expanded format or an error
+// was encountered.
+func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
+	turl := sv.FieldByName("TypeUrl")
+	val := sv.FieldByName("Value")
+	if !turl.IsValid() || !val.IsValid() {
+		return true, errors.New("proto: invalid google.protobuf.Any message")
+	}
+
+	b, ok := val.Interface().([]byte)
+	if !ok {
+		return true, errors.New("proto: invalid google.protobuf.Any message")
+	}
+
+	parts := strings.Split(turl.String(), "/")
+	mt := MessageType(parts[len(parts)-1])
+	if mt == nil {
+		return false, nil
+	}
+	m := reflect.New(mt.Elem())
+	if err := Unmarshal(b, m.Interface().(Message)); err != nil {
+		return false, nil
+	}
+	w.Write([]byte("["))
+	u := turl.String()
+	if requiresQuotes(u) {
+		writeString(w, u)
+	} else {
+		w.Write([]byte(u))
+	}
+	if w.compact {
+		w.Write([]byte("]:<"))
+	} else {
+		w.Write([]byte("]: <\n"))
+		w.ind++
+	}
+	if err := tm.writeStruct(w, m.Elem()); err != nil {
+		return true, err
+	}
+	if w.compact {
+		w.Write([]byte("> "))
+	} else {
+		w.ind--
+		w.Write([]byte(">\n"))
+	}
+	return true, nil
+}
+
+func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
+	if tm.ExpandAny && isAny(sv) {
+		if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
+			return err
+		}
+	}
+	st := sv.Type()
+	sprops := GetProperties(st)
+	for i := 0; i < sv.NumField(); i++ {
+		fv := sv.Field(i)
+		props := sprops.Prop[i]
+		name := st.Field(i).Name
+
+		if name == "XXX_NoUnkeyedLiteral" {
+			continue
+		}
+
+		if strings.HasPrefix(name, "XXX_") {
+			// There are two XXX_ fields:
+			//   XXX_unrecognized []byte
+			//   XXX_extensions   map[int32]proto.Extension
+			// The first is handled here;
+			// the second is handled at the bottom of this function.
+			if name == "XXX_unrecognized" && !fv.IsNil() {
+				if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		if fv.Kind() == reflect.Ptr && fv.IsNil() {
+			// Field not filled in. This could be an optional field or
+			// a required field that wasn't filled in. Either way, there
+			// isn't anything we can show for it.
+			continue
+		}
+		if fv.Kind() == reflect.Slice && fv.IsNil() {
+			// Repeated field that is empty, or a bytes field that is unused.
+			continue
+		}
+
+		if props.Repeated && fv.Kind() == reflect.Slice {
+			// Repeated field.
+			for j := 0; j < fv.Len(); j++ {
+				if err := writeName(w, props); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte(' '); err != nil {
+						return err
+					}
+				}
+				v := fv.Index(j)
+				if v.Kind() == reflect.Ptr && v.IsNil() {
+					// A nil message in a repeated field is not valid,
+					// but we can handle that more gracefully than panicking.
+					if _, err := w.Write([]byte("<nil>\n")); err != nil {
+						return err
+					}
+					continue
+				}
+				if err := tm.writeAny(w, v, props); err != nil {
+					return err
+				}
+				if err := w.WriteByte('\n'); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		if fv.Kind() == reflect.Map {
+			// Map fields are rendered as a repeated struct with key/value fields.
+			keys := fv.MapKeys()
+			sort.Sort(mapKeys(keys))
+			for _, key := range keys {
+				val := fv.MapIndex(key)
+				if err := writeName(w, props); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte(' '); err != nil {
+						return err
+					}
+				}
+				// open struct
+				if err := w.WriteByte('<'); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte('\n'); err != nil {
+						return err
+					}
+				}
+				w.indent()
+				// key
+				if _, err := w.WriteString("key:"); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte(' '); err != nil {
+						return err
+					}
+				}
+				if err := tm.writeAny(w, key, props.MapKeyProp); err != nil {
+					return err
+				}
+				if err := w.WriteByte('\n'); err != nil {
+					return err
+				}
+				// nil values aren't legal, but we can avoid panicking because of them.
+				if val.Kind() != reflect.Ptr || !val.IsNil() {
+					// value
+					if _, err := w.WriteString("value:"); err != nil {
+						return err
+					}
+					if !w.compact {
+						if err := w.WriteByte(' '); err != nil {
+							return err
+						}
+					}
+					if err := tm.writeAny(w, val, props.MapValProp); err != nil {
+						return err
+					}
+					if err := w.WriteByte('\n'); err != nil {
+						return err
+					}
+				}
+				// close struct
+				w.unindent()
+				if err := w.WriteByte('>'); err != nil {
+					return err
+				}
+				if err := w.WriteByte('\n'); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
+			// empty bytes field
+			continue
+		}
+		if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
+			// proto3 non-repeated scalar field; skip if zero value
+			if isProto3Zero(fv) {
+				continue
+			}
+		}
+
+		if fv.Kind() == reflect.Interface {
+			// Check if it is a oneof.
+			if st.Field(i).Tag.Get("protobuf_oneof") != "" {
+				// fv is nil, or holds a pointer to generated struct.
+				// That generated struct has exactly one field,
+				// which has a protobuf struct tag.
+				if fv.IsNil() {
+					continue
+				}
+				inner := fv.Elem().Elem() // interface -> *T -> T
+				tag := inner.Type().Field(0).Tag.Get("protobuf")
+				props = new(Properties) // Overwrite the outer props var, but not its pointee.
+				props.Parse(tag)
+				// Write the value in the oneof, not the oneof itself.
+				fv = inner.Field(0)
+
+				// Special case to cope with malformed messages gracefully:
+				// If the value in the oneof is a nil pointer, don't panic
+				// in writeAny.
+				if fv.Kind() == reflect.Ptr && fv.IsNil() {
+					// Use errors.New so writeAny won't render quotes.
+					msg := errors.New("/* nil */")
+					fv = reflect.ValueOf(&msg).Elem()
+				}
+			}
+		}
+
+		if err := writeName(w, props); err != nil {
+			return err
+		}
+		if !w.compact {
+			if err := w.WriteByte(' '); err != nil {
+				return err
+			}
+		}
+
+		// Enums have a String method, so writeAny will work fine.
+		if err := tm.writeAny(w, fv, props); err != nil {
+			return err
+		}
+
+		if err := w.WriteByte('\n'); err != nil {
+			return err
+		}
+	}
+
+	// Extensions (the XXX_extensions field).
+	pv := sv.Addr()
+	if _, err := extendable(pv.Interface()); err == nil {
+		if err := tm.writeExtensions(w, pv); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// writeAny writes an arbitrary field.
+func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
+	v = reflect.Indirect(v)
+
+	// Floats have special cases.
+	if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
+		x := v.Float()
+		var b []byte
+		switch {
+		case math.IsInf(x, 1):
+			b = posInf
+		case math.IsInf(x, -1):
+			b = negInf
+		case math.IsNaN(x):
+			b = nan
+		}
+		if b != nil {
+			_, err := w.Write(b)
+			return err
+		}
+		// Other values are handled below.
+	}
+
+	// We don't attempt to serialise every possible value type; only those
+	// that can occur in protocol buffers.
+	switch v.Kind() {
+	case reflect.Slice:
+		// Should only be a []byte; repeated fields are handled in writeStruct.
+		if err := writeString(w, string(v.Bytes())); err != nil {
+			return err
+		}
+	case reflect.String:
+		if err := writeString(w, v.String()); err != nil {
+			return err
+		}
+	case reflect.Struct:
+		// Required/optional group/message.
+		var bra, ket byte = '<', '>'
+		if props != nil && props.Wire == "group" {
+			bra, ket = '{', '}'
+		}
+		if err := w.WriteByte(bra); err != nil {
+			return err
+		}
+		if !w.compact {
+			if err := w.WriteByte('\n'); err != nil {
+				return err
+			}
+		}
+		w.indent()
+		if v.CanAddr() {
+			// Calling v.Interface on a struct causes the reflect package to
+			// copy the entire struct. This is racy with the new Marshaler
+			// since we atomically update the XXX_sizecache.
+			//
+			// Thus, we retrieve a pointer to the struct if possible to avoid
+			// a race since v.Interface on the pointer doesn't copy the struct.
+			//
+			// If v is not addressable, then we are not worried about a race
+			// since it implies that the binary Marshaler cannot possibly be
+			// mutating this value.
+			v = v.Addr()
+		}
+		if etm, ok := v.Interface().(encoding.TextMarshaler); ok {
+			text, err := etm.MarshalText()
+			if err != nil {
+				return err
+			}
+			if _, err = w.Write(text); err != nil {
+				return err
+			}
+		} else {
+			if v.Kind() == reflect.Ptr {
+				v = v.Elem()
+			}
+			if err := tm.writeStruct(w, v); err != nil {
+				return err
+			}
+		}
+		w.unindent()
+		if err := w.WriteByte(ket); err != nil {
+			return err
+		}
+	default:
+		_, err := fmt.Fprint(w, v.Interface())
+		return err
+	}
+	return nil
+}
+
+// equivalent to C's isprint.
+func isprint(c byte) bool {
+	return c >= 0x20 && c < 0x7f
+}
+
+// writeString writes a string in the protocol buffer text format.
+// It is similar to strconv.Quote except we don't use Go escape sequences,
+// we treat the string as a byte sequence, and we use octal escapes.
+// These differences are to maintain interoperability with the other
+// languages' implementations of the text format.
+func writeString(w *textWriter, s string) error {
+	// use WriteByte here to get any needed indent
+	if err := w.WriteByte('"'); err != nil {
+		return err
+	}
+	// Loop over the bytes, not the runes.
+	for i := 0; i < len(s); i++ {
+		var err error
+		// Divergence from C++: we don't escape apostrophes.
+		// There's no need to escape them, and the C++ parser
+		// copes with a naked apostrophe.
+		switch c := s[i]; c {
+		case '\n':
+			_, err = w.w.Write(backslashN)
+		case '\r':
+			_, err = w.w.Write(backslashR)
+		case '\t':
+			_, err = w.w.Write(backslashT)
+		case '"':
+			_, err = w.w.Write(backslashDQ)
+		case '\\':
+			_, err = w.w.Write(backslashBS)
+		default:
+			if isprint(c) {
+				err = w.w.WriteByte(c)
+			} else {
+				_, err = fmt.Fprintf(w.w, "\\%03o", c)
+			}
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return w.WriteByte('"')
+}
+
+func writeUnknownStruct(w *textWriter, data []byte) (err error) {
+	if !w.compact {
+		if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
+			return err
+		}
+	}
+	b := NewBuffer(data)
+	for b.index < len(b.buf) {
+		x, err := b.DecodeVarint()
+		if err != nil {
+			_, err := fmt.Fprintf(w, "/* %v */\n", err)
+			return err
+		}
+		wire, tag := x&7, x>>3
+		if wire == WireEndGroup {
+			w.unindent()
+			if _, err := w.Write(endBraceNewline); err != nil {
+				return err
+			}
+			continue
+		}
+		if _, err := fmt.Fprint(w, tag); err != nil {
+			return err
+		}
+		if wire != WireStartGroup {
+			if err := w.WriteByte(':'); err != nil {
+				return err
+			}
+		}
+		if !w.compact || wire == WireStartGroup {
+			if err := w.WriteByte(' '); err != nil {
+				return err
+			}
+		}
+		switch wire {
+		case WireBytes:
+			buf, e := b.DecodeRawBytes(false)
+			if e == nil {
+				_, err = fmt.Fprintf(w, "%q", buf)
+			} else {
+				_, err = fmt.Fprintf(w, "/* %v */", e)
+			}
+		case WireFixed32:
+			x, err = b.DecodeFixed32()
+			err = writeUnknownInt(w, x, err)
+		case WireFixed64:
+			x, err = b.DecodeFixed64()
+			err = writeUnknownInt(w, x, err)
+		case WireStartGroup:
+			err = w.WriteByte('{')
+			w.indent()
+		case WireVarint:
+			x, err = b.DecodeVarint()
+			err = writeUnknownInt(w, x, err)
+		default:
+			_, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
+		}
+		if err != nil {
+			return err
+		}
+		if err = w.WriteByte('\n'); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func writeUnknownInt(w *textWriter, x uint64, err error) error {
+	if err == nil {
+		_, err = fmt.Fprint(w, x)
+	} else {
+		_, err = fmt.Fprintf(w, "/* %v */", err)
+	}
+	return err
+}
+
+type int32Slice []int32
+
+func (s int32Slice) Len() int           { return len(s) }
+func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
+func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+// writeExtensions writes all the extensions in pv.
+// pv is assumed to be a pointer to a protocol message struct that is extendable.
+func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
+	emap := extensionMaps[pv.Type().Elem()]
+	ep, _ := extendable(pv.Interface())
+
+	// Order the extensions by ID.
+	// This isn't strictly necessary, but it will give us
+	// canonical output, which will also make testing easier.
+	m, mu := ep.extensionsRead()
+	if m == nil {
+		return nil
+	}
+	mu.Lock()
+	ids := make([]int32, 0, len(m))
+	for id := range m {
+		ids = append(ids, id)
+	}
+	sort.Sort(int32Slice(ids))
+	mu.Unlock()
+
+	for _, extNum := range ids {
+		ext := m[extNum]
+		var desc *ExtensionDesc
+		if emap != nil {
+			desc = emap[extNum]
+		}
+		if desc == nil {
+			// Unknown extension.
+			if err := writeUnknownStruct(w, ext.enc); err != nil {
+				return err
+			}
+			continue
+		}
+
+		pb, err := GetExtension(ep, desc)
+		if err != nil {
+			return fmt.Errorf("failed getting extension: %v", err)
+		}
+
+		// Repeated extensions will appear as a slice.
+		if !desc.repeated() {
+			if err := tm.writeExtension(w, desc.Name, pb); err != nil {
+				return err
+			}
+		} else {
+			v := reflect.ValueOf(pb)
+			for i := 0; i < v.Len(); i++ {
+				if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
+	if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
+		return err
+	}
+	if !w.compact {
+		if err := w.WriteByte(' '); err != nil {
+			return err
+		}
+	}
+	if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
+		return err
+	}
+	if err := w.WriteByte('\n'); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (w *textWriter) writeIndent() {
+	if !w.complete {
+		return
+	}
+	remain := w.ind * 2
+	for remain > 0 {
+		n := remain
+		if n > len(spaces) {
+			n = len(spaces)
+		}
+		w.w.Write(spaces[:n])
+		remain -= n
+	}
+	w.complete = false
+}
+
+// TextMarshaler is a configurable text format marshaler.
+type TextMarshaler struct {
+	Compact   bool // use compact text format (one line).
+	ExpandAny bool // expand google.protobuf.Any messages of known types
+}
+
+// Marshal writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
+	val := reflect.ValueOf(pb)
+	if pb == nil || val.IsNil() {
+		w.Write([]byte("<nil>"))
+		return nil
+	}
+	var bw *bufio.Writer
+	ww, ok := w.(writer)
+	if !ok {
+		bw = bufio.NewWriter(w)
+		ww = bw
+	}
+	aw := &textWriter{
+		w:        ww,
+		complete: true,
+		compact:  tm.Compact,
+	}
+
+	if etm, ok := pb.(encoding.TextMarshaler); ok {
+		text, err := etm.MarshalText()
+		if err != nil {
+			return err
+		}
+		if _, err = aw.Write(text); err != nil {
+			return err
+		}
+		if bw != nil {
+			return bw.Flush()
+		}
+		return nil
+	}
+	// Dereference the received pointer so we don't have outer < and >.
+	v := reflect.Indirect(val)
+	if err := tm.writeStruct(aw, v); err != nil {
+		return err
+	}
+	if bw != nil {
+		return bw.Flush()
+	}
+	return nil
+}
+
+// Text is the same as Marshal, but returns the string directly.
+func (tm *TextMarshaler) Text(pb Message) string {
+	var buf bytes.Buffer
+	tm.Marshal(&buf, pb)
+	return buf.String()
+}
+
+var (
+	defaultTextMarshaler = TextMarshaler{}
+	compactTextMarshaler = TextMarshaler{Compact: true}
+)
+
+// TODO: consider removing some of the Marshal functions below.
+
+// MarshalText writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
+
+// MarshalTextString is the same as MarshalText, but returns the string directly.
+func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
+
+// CompactText writes a given protocol buffer in compact text format (one line).
+func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
+
+// CompactTextString is the same as CompactText, but returns the string directly.
+func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }
diff --git a/vendor/github.com/golang/protobuf/proto/text_decode.go b/vendor/github.com/golang/protobuf/proto/text_decode.go
deleted file mode 100644
index 4a59310..0000000
--- a/vendor/github.com/golang/protobuf/proto/text_decode.go
+++ /dev/null
@@ -1,801 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"encoding"
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/encoding/prototext"
-	protoV2 "google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-const wrapTextUnmarshalV2 = false
-
-// ParseError is returned by UnmarshalText.
-type ParseError struct {
-	Message string
-
-	// Deprecated: Do not use.
-	Line, Offset int
-}
-
-func (e *ParseError) Error() string {
-	if wrapTextUnmarshalV2 {
-		return e.Message
-	}
-	if e.Line == 1 {
-		return fmt.Sprintf("line 1.%d: %v", e.Offset, e.Message)
-	}
-	return fmt.Sprintf("line %d: %v", e.Line, e.Message)
-}
-
-// UnmarshalText parses a proto text formatted string into m.
-func UnmarshalText(s string, m Message) error {
-	if u, ok := m.(encoding.TextUnmarshaler); ok {
-		return u.UnmarshalText([]byte(s))
-	}
-
-	m.Reset()
-	mi := MessageV2(m)
-
-	if wrapTextUnmarshalV2 {
-		err := prototext.UnmarshalOptions{
-			AllowPartial: true,
-		}.Unmarshal([]byte(s), mi)
-		if err != nil {
-			return &ParseError{Message: err.Error()}
-		}
-		return checkRequiredNotSet(mi)
-	} else {
-		if err := newTextParser(s).unmarshalMessage(mi.ProtoReflect(), ""); err != nil {
-			return err
-		}
-		return checkRequiredNotSet(mi)
-	}
-}
-
-type textParser struct {
-	s            string // remaining input
-	done         bool   // whether the parsing is finished (success or error)
-	backed       bool   // whether back() was called
-	offset, line int
-	cur          token
-}
-
-type token struct {
-	value    string
-	err      *ParseError
-	line     int    // line number
-	offset   int    // byte number from start of input, not start of line
-	unquoted string // the unquoted version of value, if it was a quoted string
-}
-
-func newTextParser(s string) *textParser {
-	p := new(textParser)
-	p.s = s
-	p.line = 1
-	p.cur.line = 1
-	return p
-}
-
-func (p *textParser) unmarshalMessage(m protoreflect.Message, terminator string) (err error) {
-	md := m.Descriptor()
-	fds := md.Fields()
-
-	// A struct is a sequence of "name: value", terminated by one of
-	// '>' or '}', or the end of the input.  A name may also be
-	// "[extension]" or "[type/url]".
-	//
-	// The whole struct can also be an expanded Any message, like:
-	// [type/url] < ... struct contents ... >
-	seen := make(map[protoreflect.FieldNumber]bool)
-	for {
-		tok := p.next()
-		if tok.err != nil {
-			return tok.err
-		}
-		if tok.value == terminator {
-			break
-		}
-		if tok.value == "[" {
-			if err := p.unmarshalExtensionOrAny(m, seen); err != nil {
-				return err
-			}
-			continue
-		}
-
-		// This is a normal, non-extension field.
-		name := protoreflect.Name(tok.value)
-		fd := fds.ByName(name)
-		switch {
-		case fd == nil:
-			gd := fds.ByName(protoreflect.Name(strings.ToLower(string(name))))
-			if gd != nil && gd.Kind() == protoreflect.GroupKind && gd.Message().Name() == name {
-				fd = gd
-			}
-		case fd.Kind() == protoreflect.GroupKind && fd.Message().Name() != name:
-			fd = nil
-		case fd.IsWeak() && fd.Message().IsPlaceholder():
-			fd = nil
-		}
-		if fd == nil {
-			typeName := string(md.FullName())
-			if m, ok := m.Interface().(Message); ok {
-				t := reflect.TypeOf(m)
-				if t.Kind() == reflect.Ptr {
-					typeName = t.Elem().String()
-				}
-			}
-			return p.errorf("unknown field name %q in %v", name, typeName)
-		}
-		if od := fd.ContainingOneof(); od != nil && m.WhichOneof(od) != nil {
-			return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, od.Name())
-		}
-		if fd.Cardinality() != protoreflect.Repeated && seen[fd.Number()] {
-			return p.errorf("non-repeated field %q was repeated", fd.Name())
-		}
-		seen[fd.Number()] = true
-
-		// Consume any colon.
-		if err := p.checkForColon(fd); err != nil {
-			return err
-		}
-
-		// Parse into the field.
-		v := m.Get(fd)
-		if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) {
-			v = m.Mutable(fd)
-		}
-		if v, err = p.unmarshalValue(v, fd); err != nil {
-			return err
-		}
-		m.Set(fd, v)
-
-		if err := p.consumeOptionalSeparator(); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (p *textParser) unmarshalExtensionOrAny(m protoreflect.Message, seen map[protoreflect.FieldNumber]bool) error {
-	name, err := p.consumeExtensionOrAnyName()
-	if err != nil {
-		return err
-	}
-
-	// If it contains a slash, it's an Any type URL.
-	if slashIdx := strings.LastIndex(name, "/"); slashIdx >= 0 {
-		tok := p.next()
-		if tok.err != nil {
-			return tok.err
-		}
-		// consume an optional colon
-		if tok.value == ":" {
-			tok = p.next()
-			if tok.err != nil {
-				return tok.err
-			}
-		}
-
-		var terminator string
-		switch tok.value {
-		case "<":
-			terminator = ">"
-		case "{":
-			terminator = "}"
-		default:
-			return p.errorf("expected '{' or '<', found %q", tok.value)
-		}
-
-		mt, err := protoregistry.GlobalTypes.FindMessageByURL(name)
-		if err != nil {
-			return p.errorf("unrecognized message %q in google.protobuf.Any", name[slashIdx+len("/"):])
-		}
-		m2 := mt.New()
-		if err := p.unmarshalMessage(m2, terminator); err != nil {
-			return err
-		}
-		b, err := protoV2.Marshal(m2.Interface())
-		if err != nil {
-			return p.errorf("failed to marshal message of type %q: %v", name[slashIdx+len("/"):], err)
-		}
-
-		urlFD := m.Descriptor().Fields().ByName("type_url")
-		valFD := m.Descriptor().Fields().ByName("value")
-		if seen[urlFD.Number()] {
-			return p.errorf("Any message unpacked multiple times, or %q already set", urlFD.Name())
-		}
-		if seen[valFD.Number()] {
-			return p.errorf("Any message unpacked multiple times, or %q already set", valFD.Name())
-		}
-		m.Set(urlFD, protoreflect.ValueOfString(name))
-		m.Set(valFD, protoreflect.ValueOfBytes(b))
-		seen[urlFD.Number()] = true
-		seen[valFD.Number()] = true
-		return nil
-	}
-
-	xname := protoreflect.FullName(name)
-	xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname)
-	if xt == nil && isMessageSet(m.Descriptor()) {
-		xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension"))
-	}
-	if xt == nil {
-		return p.errorf("unrecognized extension %q", name)
-	}
-	fd := xt.TypeDescriptor()
-	if fd.ContainingMessage().FullName() != m.Descriptor().FullName() {
-		return p.errorf("extension field %q does not extend message %q", name, m.Descriptor().FullName())
-	}
-
-	if err := p.checkForColon(fd); err != nil {
-		return err
-	}
-
-	v := m.Get(fd)
-	if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) {
-		v = m.Mutable(fd)
-	}
-	v, err = p.unmarshalValue(v, fd)
-	if err != nil {
-		return err
-	}
-	m.Set(fd, v)
-	return p.consumeOptionalSeparator()
-}
-
-func (p *textParser) unmarshalValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
-	tok := p.next()
-	if tok.err != nil {
-		return v, tok.err
-	}
-	if tok.value == "" {
-		return v, p.errorf("unexpected EOF")
-	}
-
-	switch {
-	case fd.IsList():
-		lv := v.List()
-		var err error
-		if tok.value == "[" {
-			// Repeated field with list notation, like [1,2,3].
-			for {
-				vv := lv.NewElement()
-				vv, err = p.unmarshalSingularValue(vv, fd)
-				if err != nil {
-					return v, err
-				}
-				lv.Append(vv)
-
-				tok := p.next()
-				if tok.err != nil {
-					return v, tok.err
-				}
-				if tok.value == "]" {
-					break
-				}
-				if tok.value != "," {
-					return v, p.errorf("Expected ']' or ',' found %q", tok.value)
-				}
-			}
-			return v, nil
-		}
-
-		// One value of the repeated field.
-		p.back()
-		vv := lv.NewElement()
-		vv, err = p.unmarshalSingularValue(vv, fd)
-		if err != nil {
-			return v, err
-		}
-		lv.Append(vv)
-		return v, nil
-	case fd.IsMap():
-		// The map entry should be this sequence of tokens:
-		//	< key : KEY value : VALUE >
-		// However, implementations may omit key or value, and technically
-		// we should support them in any order.
-		var terminator string
-		switch tok.value {
-		case "<":
-			terminator = ">"
-		case "{":
-			terminator = "}"
-		default:
-			return v, p.errorf("expected '{' or '<', found %q", tok.value)
-		}
-
-		keyFD := fd.MapKey()
-		valFD := fd.MapValue()
-
-		mv := v.Map()
-		kv := keyFD.Default()
-		vv := mv.NewValue()
-		for {
-			tok := p.next()
-			if tok.err != nil {
-				return v, tok.err
-			}
-			if tok.value == terminator {
-				break
-			}
-			var err error
-			switch tok.value {
-			case "key":
-				if err := p.consumeToken(":"); err != nil {
-					return v, err
-				}
-				if kv, err = p.unmarshalSingularValue(kv, keyFD); err != nil {
-					return v, err
-				}
-				if err := p.consumeOptionalSeparator(); err != nil {
-					return v, err
-				}
-			case "value":
-				if err := p.checkForColon(valFD); err != nil {
-					return v, err
-				}
-				if vv, err = p.unmarshalSingularValue(vv, valFD); err != nil {
-					return v, err
-				}
-				if err := p.consumeOptionalSeparator(); err != nil {
-					return v, err
-				}
-			default:
-				p.back()
-				return v, p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
-			}
-		}
-		mv.Set(kv.MapKey(), vv)
-		return v, nil
-	default:
-		p.back()
-		return p.unmarshalSingularValue(v, fd)
-	}
-}
-
-func (p *textParser) unmarshalSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
-	tok := p.next()
-	if tok.err != nil {
-		return v, tok.err
-	}
-	if tok.value == "" {
-		return v, p.errorf("unexpected EOF")
-	}
-
-	switch fd.Kind() {
-	case protoreflect.BoolKind:
-		switch tok.value {
-		case "true", "1", "t", "True":
-			return protoreflect.ValueOfBool(true), nil
-		case "false", "0", "f", "False":
-			return protoreflect.ValueOfBool(false), nil
-		}
-	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
-		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
-			return protoreflect.ValueOfInt32(int32(x)), nil
-		}
-
-		// The C++ parser accepts large positive hex numbers that uses
-		// two's complement arithmetic to represent negative numbers.
-		// This feature is here for backwards compatibility with C++.
-		if strings.HasPrefix(tok.value, "0x") {
-			if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
-				return protoreflect.ValueOfInt32(int32(-(int64(^x) + 1))), nil
-			}
-		}
-	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
-		if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
-			return protoreflect.ValueOfInt64(int64(x)), nil
-		}
-
-		// The C++ parser accepts large positive hex numbers that uses
-		// two's complement arithmetic to represent negative numbers.
-		// This feature is here for backwards compatibility with C++.
-		if strings.HasPrefix(tok.value, "0x") {
-			if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
-				return protoreflect.ValueOfInt64(int64(-(int64(^x) + 1))), nil
-			}
-		}
-	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
-		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
-			return protoreflect.ValueOfUint32(uint32(x)), nil
-		}
-	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
-		if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
-			return protoreflect.ValueOfUint64(uint64(x)), nil
-		}
-	case protoreflect.FloatKind:
-		// Ignore 'f' for compatibility with output generated by C++,
-		// but don't remove 'f' when the value is "-inf" or "inf".
-		v := tok.value
-		if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" {
-			v = v[:len(v)-len("f")]
-		}
-		if x, err := strconv.ParseFloat(v, 32); err == nil {
-			return protoreflect.ValueOfFloat32(float32(x)), nil
-		}
-	case protoreflect.DoubleKind:
-		// Ignore 'f' for compatibility with output generated by C++,
-		// but don't remove 'f' when the value is "-inf" or "inf".
-		v := tok.value
-		if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" {
-			v = v[:len(v)-len("f")]
-		}
-		if x, err := strconv.ParseFloat(v, 64); err == nil {
-			return protoreflect.ValueOfFloat64(float64(x)), nil
-		}
-	case protoreflect.StringKind:
-		if isQuote(tok.value[0]) {
-			return protoreflect.ValueOfString(tok.unquoted), nil
-		}
-	case protoreflect.BytesKind:
-		if isQuote(tok.value[0]) {
-			return protoreflect.ValueOfBytes([]byte(tok.unquoted)), nil
-		}
-	case protoreflect.EnumKind:
-		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
-			return protoreflect.ValueOfEnum(protoreflect.EnumNumber(x)), nil
-		}
-		vd := fd.Enum().Values().ByName(protoreflect.Name(tok.value))
-		if vd != nil {
-			return protoreflect.ValueOfEnum(vd.Number()), nil
-		}
-	case protoreflect.MessageKind, protoreflect.GroupKind:
-		var terminator string
-		switch tok.value {
-		case "{":
-			terminator = "}"
-		case "<":
-			terminator = ">"
-		default:
-			return v, p.errorf("expected '{' or '<', found %q", tok.value)
-		}
-		err := p.unmarshalMessage(v.Message(), terminator)
-		return v, err
-	default:
-		panic(fmt.Sprintf("invalid kind %v", fd.Kind()))
-	}
-	return v, p.errorf("invalid %v: %v", fd.Kind(), tok.value)
-}
-
-// Consume a ':' from the input stream (if the next token is a colon),
-// returning an error if a colon is needed but not present.
-func (p *textParser) checkForColon(fd protoreflect.FieldDescriptor) *ParseError {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != ":" {
-		if fd.Message() == nil {
-			return p.errorf("expected ':', found %q", tok.value)
-		}
-		p.back()
-	}
-	return nil
-}
-
-// consumeExtensionOrAnyName consumes an extension name or an Any type URL and
-// the following ']'. It returns the name or URL consumed.
-func (p *textParser) consumeExtensionOrAnyName() (string, error) {
-	tok := p.next()
-	if tok.err != nil {
-		return "", tok.err
-	}
-
-	// If extension name or type url is quoted, it's a single token.
-	if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
-		name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
-		if err != nil {
-			return "", err
-		}
-		return name, p.consumeToken("]")
-	}
-
-	// Consume everything up to "]"
-	var parts []string
-	for tok.value != "]" {
-		parts = append(parts, tok.value)
-		tok = p.next()
-		if tok.err != nil {
-			return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
-		}
-		if p.done && tok.value != "]" {
-			return "", p.errorf("unclosed type_url or extension name")
-		}
-	}
-	return strings.Join(parts, ""), nil
-}
-
-// consumeOptionalSeparator consumes an optional semicolon or comma.
-// It is used in unmarshalMessage to provide backward compatibility.
-func (p *textParser) consumeOptionalSeparator() error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != ";" && tok.value != "," {
-		p.back()
-	}
-	return nil
-}
-
-func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
-	pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
-	p.cur.err = pe
-	p.done = true
-	return pe
-}
-
-func (p *textParser) skipWhitespace() {
-	i := 0
-	for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
-		if p.s[i] == '#' {
-			// comment; skip to end of line or input
-			for i < len(p.s) && p.s[i] != '\n' {
-				i++
-			}
-			if i == len(p.s) {
-				break
-			}
-		}
-		if p.s[i] == '\n' {
-			p.line++
-		}
-		i++
-	}
-	p.offset += i
-	p.s = p.s[i:len(p.s)]
-	if len(p.s) == 0 {
-		p.done = true
-	}
-}
-
-func (p *textParser) advance() {
-	// Skip whitespace
-	p.skipWhitespace()
-	if p.done {
-		return
-	}
-
-	// Start of non-whitespace
-	p.cur.err = nil
-	p.cur.offset, p.cur.line = p.offset, p.line
-	p.cur.unquoted = ""
-	switch p.s[0] {
-	case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
-		// Single symbol
-		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
-	case '"', '\'':
-		// Quoted string
-		i := 1
-		for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
-			if p.s[i] == '\\' && i+1 < len(p.s) {
-				// skip escaped char
-				i++
-			}
-			i++
-		}
-		if i >= len(p.s) || p.s[i] != p.s[0] {
-			p.errorf("unmatched quote")
-			return
-		}
-		unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
-		if err != nil {
-			p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
-			return
-		}
-		p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
-		p.cur.unquoted = unq
-	default:
-		i := 0
-		for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
-			i++
-		}
-		if i == 0 {
-			p.errorf("unexpected byte %#x", p.s[0])
-			return
-		}
-		p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
-	}
-	p.offset += len(p.cur.value)
-}
-
-// Back off the parser by one token. Can only be done between calls to next().
-// It makes the next advance() a no-op.
-func (p *textParser) back() { p.backed = true }
-
-// Advances the parser and returns the new current token.
-func (p *textParser) next() *token {
-	if p.backed || p.done {
-		p.backed = false
-		return &p.cur
-	}
-	p.advance()
-	if p.done {
-		p.cur.value = ""
-	} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
-		// Look for multiple quoted strings separated by whitespace,
-		// and concatenate them.
-		cat := p.cur
-		for {
-			p.skipWhitespace()
-			if p.done || !isQuote(p.s[0]) {
-				break
-			}
-			p.advance()
-			if p.cur.err != nil {
-				return &p.cur
-			}
-			cat.value += " " + p.cur.value
-			cat.unquoted += p.cur.unquoted
-		}
-		p.done = false // parser may have seen EOF, but we want to return cat
-		p.cur = cat
-	}
-	return &p.cur
-}
-
-func (p *textParser) consumeToken(s string) error {
-	tok := p.next()
-	if tok.err != nil {
-		return tok.err
-	}
-	if tok.value != s {
-		p.back()
-		return p.errorf("expected %q, found %q", s, tok.value)
-	}
-	return nil
-}
-
-var errBadUTF8 = errors.New("proto: bad UTF-8")
-
-func unquoteC(s string, quote rune) (string, error) {
-	// This is based on C++'s tokenizer.cc.
-	// Despite its name, this is *not* parsing C syntax.
-	// For instance, "\0" is an invalid quoted string.
-
-	// Avoid allocation in trivial cases.
-	simple := true
-	for _, r := range s {
-		if r == '\\' || r == quote {
-			simple = false
-			break
-		}
-	}
-	if simple {
-		return s, nil
-	}
-
-	buf := make([]byte, 0, 3*len(s)/2)
-	for len(s) > 0 {
-		r, n := utf8.DecodeRuneInString(s)
-		if r == utf8.RuneError && n == 1 {
-			return "", errBadUTF8
-		}
-		s = s[n:]
-		if r != '\\' {
-			if r < utf8.RuneSelf {
-				buf = append(buf, byte(r))
-			} else {
-				buf = append(buf, string(r)...)
-			}
-			continue
-		}
-
-		ch, tail, err := unescape(s)
-		if err != nil {
-			return "", err
-		}
-		buf = append(buf, ch...)
-		s = tail
-	}
-	return string(buf), nil
-}
-
-func unescape(s string) (ch string, tail string, err error) {
-	r, n := utf8.DecodeRuneInString(s)
-	if r == utf8.RuneError && n == 1 {
-		return "", "", errBadUTF8
-	}
-	s = s[n:]
-	switch r {
-	case 'a':
-		return "\a", s, nil
-	case 'b':
-		return "\b", s, nil
-	case 'f':
-		return "\f", s, nil
-	case 'n':
-		return "\n", s, nil
-	case 'r':
-		return "\r", s, nil
-	case 't':
-		return "\t", s, nil
-	case 'v':
-		return "\v", s, nil
-	case '?':
-		return "?", s, nil // trigraph workaround
-	case '\'', '"', '\\':
-		return string(r), s, nil
-	case '0', '1', '2', '3', '4', '5', '6', '7':
-		if len(s) < 2 {
-			return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
-		}
-		ss := string(r) + s[:2]
-		s = s[2:]
-		i, err := strconv.ParseUint(ss, 8, 8)
-		if err != nil {
-			return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
-		}
-		return string([]byte{byte(i)}), s, nil
-	case 'x', 'X', 'u', 'U':
-		var n int
-		switch r {
-		case 'x', 'X':
-			n = 2
-		case 'u':
-			n = 4
-		case 'U':
-			n = 8
-		}
-		if len(s) < n {
-			return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
-		}
-		ss := s[:n]
-		s = s[n:]
-		i, err := strconv.ParseUint(ss, 16, 64)
-		if err != nil {
-			return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
-		}
-		if r == 'x' || r == 'X' {
-			return string([]byte{byte(i)}), s, nil
-		}
-		if i > utf8.MaxRune {
-			return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
-		}
-		return string(i), s, nil
-	}
-	return "", "", fmt.Errorf(`unknown escape \%c`, r)
-}
-
-func isIdentOrNumberChar(c byte) bool {
-	switch {
-	case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
-		return true
-	case '0' <= c && c <= '9':
-		return true
-	}
-	switch c {
-	case '-', '+', '.', '_':
-		return true
-	}
-	return false
-}
-
-func isWhitespace(c byte) bool {
-	switch c {
-	case ' ', '\t', '\n', '\r':
-		return true
-	}
-	return false
-}
-
-func isQuote(c byte) bool {
-	switch c {
-	case '"', '\'':
-		return true
-	}
-	return false
-}
diff --git a/vendor/github.com/golang/protobuf/proto/text_encode.go b/vendor/github.com/golang/protobuf/proto/text_encode.go
deleted file mode 100644
index a31134e..0000000
--- a/vendor/github.com/golang/protobuf/proto/text_encode.go
+++ /dev/null
@@ -1,560 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"bytes"
-	"encoding"
-	"fmt"
-	"io"
-	"math"
-	"sort"
-	"strings"
-
-	"google.golang.org/protobuf/encoding/prototext"
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-const wrapTextMarshalV2 = false
-
-// TextMarshaler is a configurable text format marshaler.
-type TextMarshaler struct {
-	Compact   bool // use compact text format (one line)
-	ExpandAny bool // expand google.protobuf.Any messages of known types
-}
-
-// Marshal writes the proto text format of m to w.
-func (tm *TextMarshaler) Marshal(w io.Writer, m Message) error {
-	b, err := tm.marshal(m)
-	if len(b) > 0 {
-		if _, err := w.Write(b); err != nil {
-			return err
-		}
-	}
-	return err
-}
-
-// Text returns a proto text formatted string of m.
-func (tm *TextMarshaler) Text(m Message) string {
-	b, _ := tm.marshal(m)
-	return string(b)
-}
-
-func (tm *TextMarshaler) marshal(m Message) ([]byte, error) {
-	mr := MessageReflect(m)
-	if mr == nil || !mr.IsValid() {
-		return []byte("<nil>"), nil
-	}
-
-	if wrapTextMarshalV2 {
-		if m, ok := m.(encoding.TextMarshaler); ok {
-			return m.MarshalText()
-		}
-
-		opts := prototext.MarshalOptions{
-			AllowPartial: true,
-			EmitUnknown:  true,
-		}
-		if !tm.Compact {
-			opts.Indent = "  "
-		}
-		if !tm.ExpandAny {
-			opts.Resolver = (*protoregistry.Types)(nil)
-		}
-		return opts.Marshal(mr.Interface())
-	} else {
-		w := &textWriter{
-			compact:   tm.Compact,
-			expandAny: tm.ExpandAny,
-			complete:  true,
-		}
-
-		if m, ok := m.(encoding.TextMarshaler); ok {
-			b, err := m.MarshalText()
-			if err != nil {
-				return nil, err
-			}
-			w.Write(b)
-			return w.buf, nil
-		}
-
-		err := w.writeMessage(mr)
-		return w.buf, err
-	}
-}
-
-var (
-	defaultTextMarshaler = TextMarshaler{}
-	compactTextMarshaler = TextMarshaler{Compact: true}
-)
-
-// MarshalText writes the proto text format of m to w.
-func MarshalText(w io.Writer, m Message) error { return defaultTextMarshaler.Marshal(w, m) }
-
-// MarshalTextString returns a proto text formatted string of m.
-func MarshalTextString(m Message) string { return defaultTextMarshaler.Text(m) }
-
-// CompactText writes the compact proto text format of m to w.
-func CompactText(w io.Writer, m Message) error { return compactTextMarshaler.Marshal(w, m) }
-
-// CompactTextString returns a compact proto text formatted string of m.
-func CompactTextString(m Message) string { return compactTextMarshaler.Text(m) }
-
-var (
-	newline         = []byte("\n")
-	endBraceNewline = []byte("}\n")
-	posInf          = []byte("inf")
-	negInf          = []byte("-inf")
-	nan             = []byte("nan")
-)
-
-// textWriter is an io.Writer that tracks its indentation level.
-type textWriter struct {
-	compact   bool // same as TextMarshaler.Compact
-	expandAny bool // same as TextMarshaler.ExpandAny
-	complete  bool // whether the current position is a complete line
-	indent    int  // indentation level; never negative
-	buf       []byte
-}
-
-func (w *textWriter) Write(p []byte) (n int, _ error) {
-	newlines := bytes.Count(p, newline)
-	if newlines == 0 {
-		if !w.compact && w.complete {
-			w.writeIndent()
-		}
-		w.buf = append(w.buf, p...)
-		w.complete = false
-		return len(p), nil
-	}
-
-	frags := bytes.SplitN(p, newline, newlines+1)
-	if w.compact {
-		for i, frag := range frags {
-			if i > 0 {
-				w.buf = append(w.buf, ' ')
-				n++
-			}
-			w.buf = append(w.buf, frag...)
-			n += len(frag)
-		}
-		return n, nil
-	}
-
-	for i, frag := range frags {
-		if w.complete {
-			w.writeIndent()
-		}
-		w.buf = append(w.buf, frag...)
-		n += len(frag)
-		if i+1 < len(frags) {
-			w.buf = append(w.buf, '\n')
-			n++
-		}
-	}
-	w.complete = len(frags[len(frags)-1]) == 0
-	return n, nil
-}
-
-func (w *textWriter) WriteByte(c byte) error {
-	if w.compact && c == '\n' {
-		c = ' '
-	}
-	if !w.compact && w.complete {
-		w.writeIndent()
-	}
-	w.buf = append(w.buf, c)
-	w.complete = c == '\n'
-	return nil
-}
-
-func (w *textWriter) writeName(fd protoreflect.FieldDescriptor) {
-	if !w.compact && w.complete {
-		w.writeIndent()
-	}
-	w.complete = false
-
-	if fd.Kind() != protoreflect.GroupKind {
-		w.buf = append(w.buf, fd.Name()...)
-		w.WriteByte(':')
-	} else {
-		// Use message type name for group field name.
-		w.buf = append(w.buf, fd.Message().Name()...)
-	}
-
-	if !w.compact {
-		w.WriteByte(' ')
-	}
-}
-
-func requiresQuotes(u string) bool {
-	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
-	for _, ch := range u {
-		switch {
-		case ch == '.' || ch == '/' || ch == '_':
-			continue
-		case '0' <= ch && ch <= '9':
-			continue
-		case 'A' <= ch && ch <= 'Z':
-			continue
-		case 'a' <= ch && ch <= 'z':
-			continue
-		default:
-			return true
-		}
-	}
-	return false
-}
-
-// writeProto3Any writes an expanded google.protobuf.Any message.
-//
-// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
-// required messages are not linked in).
-//
-// It returns (true, error) when sv was written in expanded format or an error
-// was encountered.
-func (w *textWriter) writeProto3Any(m protoreflect.Message) (bool, error) {
-	md := m.Descriptor()
-	fdURL := md.Fields().ByName("type_url")
-	fdVal := md.Fields().ByName("value")
-
-	url := m.Get(fdURL).String()
-	mt, err := protoregistry.GlobalTypes.FindMessageByURL(url)
-	if err != nil {
-		return false, nil
-	}
-
-	b := m.Get(fdVal).Bytes()
-	m2 := mt.New()
-	if err := proto.Unmarshal(b, m2.Interface()); err != nil {
-		return false, nil
-	}
-	w.Write([]byte("["))
-	if requiresQuotes(url) {
-		w.writeQuotedString(url)
-	} else {
-		w.Write([]byte(url))
-	}
-	if w.compact {
-		w.Write([]byte("]:<"))
-	} else {
-		w.Write([]byte("]: <\n"))
-		w.indent++
-	}
-	if err := w.writeMessage(m2); err != nil {
-		return true, err
-	}
-	if w.compact {
-		w.Write([]byte("> "))
-	} else {
-		w.indent--
-		w.Write([]byte(">\n"))
-	}
-	return true, nil
-}
-
-func (w *textWriter) writeMessage(m protoreflect.Message) error {
-	md := m.Descriptor()
-	if w.expandAny && md.FullName() == "google.protobuf.Any" {
-		if canExpand, err := w.writeProto3Any(m); canExpand {
-			return err
-		}
-	}
-
-	fds := md.Fields()
-	for i := 0; i < fds.Len(); {
-		fd := fds.Get(i)
-		if od := fd.ContainingOneof(); od != nil {
-			fd = m.WhichOneof(od)
-			i += od.Fields().Len()
-		} else {
-			i++
-		}
-		if fd == nil || !m.Has(fd) {
-			continue
-		}
-
-		switch {
-		case fd.IsList():
-			lv := m.Get(fd).List()
-			for j := 0; j < lv.Len(); j++ {
-				w.writeName(fd)
-				v := lv.Get(j)
-				if err := w.writeSingularValue(v, fd); err != nil {
-					return err
-				}
-				w.WriteByte('\n')
-			}
-		case fd.IsMap():
-			kfd := fd.MapKey()
-			vfd := fd.MapValue()
-			mv := m.Get(fd).Map()
-
-			type entry struct{ key, val protoreflect.Value }
-			var entries []entry
-			mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
-				entries = append(entries, entry{k.Value(), v})
-				return true
-			})
-			sort.Slice(entries, func(i, j int) bool {
-				switch kfd.Kind() {
-				case protoreflect.BoolKind:
-					return !entries[i].key.Bool() && entries[j].key.Bool()
-				case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
-					return entries[i].key.Int() < entries[j].key.Int()
-				case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
-					return entries[i].key.Uint() < entries[j].key.Uint()
-				case protoreflect.StringKind:
-					return entries[i].key.String() < entries[j].key.String()
-				default:
-					panic("invalid kind")
-				}
-			})
-			for _, entry := range entries {
-				w.writeName(fd)
-				w.WriteByte('<')
-				if !w.compact {
-					w.WriteByte('\n')
-				}
-				w.indent++
-				w.writeName(kfd)
-				if err := w.writeSingularValue(entry.key, kfd); err != nil {
-					return err
-				}
-				w.WriteByte('\n')
-				w.writeName(vfd)
-				if err := w.writeSingularValue(entry.val, vfd); err != nil {
-					return err
-				}
-				w.WriteByte('\n')
-				w.indent--
-				w.WriteByte('>')
-				w.WriteByte('\n')
-			}
-		default:
-			w.writeName(fd)
-			if err := w.writeSingularValue(m.Get(fd), fd); err != nil {
-				return err
-			}
-			w.WriteByte('\n')
-		}
-	}
-
-	if b := m.GetUnknown(); len(b) > 0 {
-		w.writeUnknownFields(b)
-	}
-	return w.writeExtensions(m)
-}
-
-func (w *textWriter) writeSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) error {
-	switch fd.Kind() {
-	case protoreflect.FloatKind, protoreflect.DoubleKind:
-		switch vf := v.Float(); {
-		case math.IsInf(vf, +1):
-			w.Write(posInf)
-		case math.IsInf(vf, -1):
-			w.Write(negInf)
-		case math.IsNaN(vf):
-			w.Write(nan)
-		default:
-			fmt.Fprint(w, v.Interface())
-		}
-	case protoreflect.StringKind:
-		// NOTE: This does not validate UTF-8 for historical reasons.
-		w.writeQuotedString(string(v.String()))
-	case protoreflect.BytesKind:
-		w.writeQuotedString(string(v.Bytes()))
-	case protoreflect.MessageKind, protoreflect.GroupKind:
-		var bra, ket byte = '<', '>'
-		if fd.Kind() == protoreflect.GroupKind {
-			bra, ket = '{', '}'
-		}
-		w.WriteByte(bra)
-		if !w.compact {
-			w.WriteByte('\n')
-		}
-		w.indent++
-		m := v.Message()
-		if m2, ok := m.Interface().(encoding.TextMarshaler); ok {
-			b, err := m2.MarshalText()
-			if err != nil {
-				return err
-			}
-			w.Write(b)
-		} else {
-			w.writeMessage(m)
-		}
-		w.indent--
-		w.WriteByte(ket)
-	case protoreflect.EnumKind:
-		if ev := fd.Enum().Values().ByNumber(v.Enum()); ev != nil {
-			fmt.Fprint(w, ev.Name())
-		} else {
-			fmt.Fprint(w, v.Enum())
-		}
-	default:
-		fmt.Fprint(w, v.Interface())
-	}
-	return nil
-}
-
-// writeQuotedString writes a quoted string in the protocol buffer text format.
-func (w *textWriter) writeQuotedString(s string) {
-	w.WriteByte('"')
-	for i := 0; i < len(s); i++ {
-		switch c := s[i]; c {
-		case '\n':
-			w.buf = append(w.buf, `\n`...)
-		case '\r':
-			w.buf = append(w.buf, `\r`...)
-		case '\t':
-			w.buf = append(w.buf, `\t`...)
-		case '"':
-			w.buf = append(w.buf, `\"`...)
-		case '\\':
-			w.buf = append(w.buf, `\\`...)
-		default:
-			if isPrint := c >= 0x20 && c < 0x7f; isPrint {
-				w.buf = append(w.buf, c)
-			} else {
-				w.buf = append(w.buf, fmt.Sprintf(`\%03o`, c)...)
-			}
-		}
-	}
-	w.WriteByte('"')
-}
-
-func (w *textWriter) writeUnknownFields(b []byte) {
-	if !w.compact {
-		fmt.Fprintf(w, "/* %d unknown bytes */\n", len(b))
-	}
-
-	for len(b) > 0 {
-		num, wtyp, n := protowire.ConsumeTag(b)
-		if n < 0 {
-			return
-		}
-		b = b[n:]
-
-		if wtyp == protowire.EndGroupType {
-			w.indent--
-			w.Write(endBraceNewline)
-			continue
-		}
-		fmt.Fprint(w, num)
-		if wtyp != protowire.StartGroupType {
-			w.WriteByte(':')
-		}
-		if !w.compact || wtyp == protowire.StartGroupType {
-			w.WriteByte(' ')
-		}
-		switch wtyp {
-		case protowire.VarintType:
-			v, n := protowire.ConsumeVarint(b)
-			if n < 0 {
-				return
-			}
-			b = b[n:]
-			fmt.Fprint(w, v)
-		case protowire.Fixed32Type:
-			v, n := protowire.ConsumeFixed32(b)
-			if n < 0 {
-				return
-			}
-			b = b[n:]
-			fmt.Fprint(w, v)
-		case protowire.Fixed64Type:
-			v, n := protowire.ConsumeFixed64(b)
-			if n < 0 {
-				return
-			}
-			b = b[n:]
-			fmt.Fprint(w, v)
-		case protowire.BytesType:
-			v, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return
-			}
-			b = b[n:]
-			fmt.Fprintf(w, "%q", v)
-		case protowire.StartGroupType:
-			w.WriteByte('{')
-			w.indent++
-		default:
-			fmt.Fprintf(w, "/* unknown wire type %d */", wtyp)
-		}
-		w.WriteByte('\n')
-	}
-}
-
-// writeExtensions writes all the extensions in m.
-func (w *textWriter) writeExtensions(m protoreflect.Message) error {
-	md := m.Descriptor()
-	if md.ExtensionRanges().Len() == 0 {
-		return nil
-	}
-
-	type ext struct {
-		desc protoreflect.FieldDescriptor
-		val  protoreflect.Value
-	}
-	var exts []ext
-	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		if fd.IsExtension() {
-			exts = append(exts, ext{fd, v})
-		}
-		return true
-	})
-	sort.Slice(exts, func(i, j int) bool {
-		return exts[i].desc.Number() < exts[j].desc.Number()
-	})
-
-	for _, ext := range exts {
-		// For message set, use the name of the message as the extension name.
-		name := string(ext.desc.FullName())
-		if isMessageSet(ext.desc.ContainingMessage()) {
-			name = strings.TrimSuffix(name, ".message_set_extension")
-		}
-
-		if !ext.desc.IsList() {
-			if err := w.writeSingularExtension(name, ext.val, ext.desc); err != nil {
-				return err
-			}
-		} else {
-			lv := ext.val.List()
-			for i := 0; i < lv.Len(); i++ {
-				if err := w.writeSingularExtension(name, lv.Get(i), ext.desc); err != nil {
-					return err
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func (w *textWriter) writeSingularExtension(name string, v protoreflect.Value, fd protoreflect.FieldDescriptor) error {
-	fmt.Fprintf(w, "[%s]:", name)
-	if !w.compact {
-		w.WriteByte(' ')
-	}
-	if err := w.writeSingularValue(v, fd); err != nil {
-		return err
-	}
-	w.WriteByte('\n')
-	return nil
-}
-
-func (w *textWriter) writeIndent() {
-	if !w.complete {
-		return
-	}
-	for i := 0; i < w.indent*2; i++ {
-		w.buf = append(w.buf, ' ')
-	}
-	w.complete = false
-}
diff --git a/vendor/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/golang/protobuf/proto/text_parser.go
new file mode 100644
index 0000000..bb55a3a
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/text_parser.go
@@ -0,0 +1,880 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// Functions for parsing the Text protocol buffer format.
+// TODO: message sets.
+
+import (
+	"encoding"
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+// Error string emitted when deserializing Any and fields are already set
+const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
+
+type ParseError struct {
+	Message string
+	Line    int // 1-based line number
+	Offset  int // 0-based byte offset from start of input
+}
+
+func (p *ParseError) Error() string {
+	if p.Line == 1 {
+		// show offset only for first line
+		return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
+	}
+	return fmt.Sprintf("line %d: %v", p.Line, p.Message)
+}
+
+type token struct {
+	value    string
+	err      *ParseError
+	line     int    // line number
+	offset   int    // byte number from start of input, not start of line
+	unquoted string // the unquoted version of value, if it was a quoted string
+}
+
+func (t *token) String() string {
+	if t.err == nil {
+		return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
+	}
+	return fmt.Sprintf("parse error: %v", t.err)
+}
+
+type textParser struct {
+	s            string // remaining input
+	done         bool   // whether the parsing is finished (success or error)
+	backed       bool   // whether back() was called
+	offset, line int
+	cur          token
+}
+
+func newTextParser(s string) *textParser {
+	p := new(textParser)
+	p.s = s
+	p.line = 1
+	p.cur.line = 1
+	return p
+}
+
+func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
+	pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
+	p.cur.err = pe
+	p.done = true
+	return pe
+}
+
+// Numbers and identifiers are matched by [-+._A-Za-z0-9]
+func isIdentOrNumberChar(c byte) bool {
+	switch {
+	case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
+		return true
+	case '0' <= c && c <= '9':
+		return true
+	}
+	switch c {
+	case '-', '+', '.', '_':
+		return true
+	}
+	return false
+}
+
+func isWhitespace(c byte) bool {
+	switch c {
+	case ' ', '\t', '\n', '\r':
+		return true
+	}
+	return false
+}
+
+func isQuote(c byte) bool {
+	switch c {
+	case '"', '\'':
+		return true
+	}
+	return false
+}
+
+func (p *textParser) skipWhitespace() {
+	i := 0
+	for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
+		if p.s[i] == '#' {
+			// comment; skip to end of line or input
+			for i < len(p.s) && p.s[i] != '\n' {
+				i++
+			}
+			if i == len(p.s) {
+				break
+			}
+		}
+		if p.s[i] == '\n' {
+			p.line++
+		}
+		i++
+	}
+	p.offset += i
+	p.s = p.s[i:len(p.s)]
+	if len(p.s) == 0 {
+		p.done = true
+	}
+}
+
+func (p *textParser) advance() {
+	// Skip whitespace
+	p.skipWhitespace()
+	if p.done {
+		return
+	}
+
+	// Start of non-whitespace
+	p.cur.err = nil
+	p.cur.offset, p.cur.line = p.offset, p.line
+	p.cur.unquoted = ""
+	switch p.s[0] {
+	case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
+		// Single symbol
+		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
+	case '"', '\'':
+		// Quoted string
+		i := 1
+		for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
+			if p.s[i] == '\\' && i+1 < len(p.s) {
+				// skip escaped char
+				i++
+			}
+			i++
+		}
+		if i >= len(p.s) || p.s[i] != p.s[0] {
+			p.errorf("unmatched quote")
+			return
+		}
+		unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
+		if err != nil {
+			p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
+			return
+		}
+		p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
+		p.cur.unquoted = unq
+	default:
+		i := 0
+		for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
+			i++
+		}
+		if i == 0 {
+			p.errorf("unexpected byte %#x", p.s[0])
+			return
+		}
+		p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
+	}
+	p.offset += len(p.cur.value)
+}
+
+var (
+	errBadUTF8 = errors.New("proto: bad UTF-8")
+)
+
+func unquoteC(s string, quote rune) (string, error) {
+	// This is based on C++'s tokenizer.cc.
+	// Despite its name, this is *not* parsing C syntax.
+	// For instance, "\0" is an invalid quoted string.
+
+	// Avoid allocation in trivial cases.
+	simple := true
+	for _, r := range s {
+		if r == '\\' || r == quote {
+			simple = false
+			break
+		}
+	}
+	if simple {
+		return s, nil
+	}
+
+	buf := make([]byte, 0, 3*len(s)/2)
+	for len(s) > 0 {
+		r, n := utf8.DecodeRuneInString(s)
+		if r == utf8.RuneError && n == 1 {
+			return "", errBadUTF8
+		}
+		s = s[n:]
+		if r != '\\' {
+			if r < utf8.RuneSelf {
+				buf = append(buf, byte(r))
+			} else {
+				buf = append(buf, string(r)...)
+			}
+			continue
+		}
+
+		ch, tail, err := unescape(s)
+		if err != nil {
+			return "", err
+		}
+		buf = append(buf, ch...)
+		s = tail
+	}
+	return string(buf), nil
+}
+
+func unescape(s string) (ch string, tail string, err error) {
+	r, n := utf8.DecodeRuneInString(s)
+	if r == utf8.RuneError && n == 1 {
+		return "", "", errBadUTF8
+	}
+	s = s[n:]
+	switch r {
+	case 'a':
+		return "\a", s, nil
+	case 'b':
+		return "\b", s, nil
+	case 'f':
+		return "\f", s, nil
+	case 'n':
+		return "\n", s, nil
+	case 'r':
+		return "\r", s, nil
+	case 't':
+		return "\t", s, nil
+	case 'v':
+		return "\v", s, nil
+	case '?':
+		return "?", s, nil // trigraph workaround
+	case '\'', '"', '\\':
+		return string(r), s, nil
+	case '0', '1', '2', '3', '4', '5', '6', '7':
+		if len(s) < 2 {
+			return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
+		}
+		ss := string(r) + s[:2]
+		s = s[2:]
+		i, err := strconv.ParseUint(ss, 8, 8)
+		if err != nil {
+			return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)
+		}
+		return string([]byte{byte(i)}), s, nil
+	case 'x', 'X', 'u', 'U':
+		var n int
+		switch r {
+		case 'x', 'X':
+			n = 2
+		case 'u':
+			n = 4
+		case 'U':
+			n = 8
+		}
+		if len(s) < n {
+			return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)
+		}
+		ss := s[:n]
+		s = s[n:]
+		i, err := strconv.ParseUint(ss, 16, 64)
+		if err != nil {
+			return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)
+		}
+		if r == 'x' || r == 'X' {
+			return string([]byte{byte(i)}), s, nil
+		}
+		if i > utf8.MaxRune {
+			return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)
+		}
+		return string(i), s, nil
+	}
+	return "", "", fmt.Errorf(`unknown escape \%c`, r)
+}
+
+// Back off the parser by one token. Can only be done between calls to next().
+// It makes the next advance() a no-op.
+func (p *textParser) back() { p.backed = true }
+
+// Advances the parser and returns the new current token.
+func (p *textParser) next() *token {
+	if p.backed || p.done {
+		p.backed = false
+		return &p.cur
+	}
+	p.advance()
+	if p.done {
+		p.cur.value = ""
+	} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
+		// Look for multiple quoted strings separated by whitespace,
+		// and concatenate them.
+		cat := p.cur
+		for {
+			p.skipWhitespace()
+			if p.done || !isQuote(p.s[0]) {
+				break
+			}
+			p.advance()
+			if p.cur.err != nil {
+				return &p.cur
+			}
+			cat.value += " " + p.cur.value
+			cat.unquoted += p.cur.unquoted
+		}
+		p.done = false // parser may have seen EOF, but we want to return cat
+		p.cur = cat
+	}
+	return &p.cur
+}
+
+func (p *textParser) consumeToken(s string) error {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != s {
+		p.back()
+		return p.errorf("expected %q, found %q", s, tok.value)
+	}
+	return nil
+}
+
+// Return a RequiredNotSetError indicating which required field was not set.
+func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
+	st := sv.Type()
+	sprops := GetProperties(st)
+	for i := 0; i < st.NumField(); i++ {
+		if !isNil(sv.Field(i)) {
+			continue
+		}
+
+		props := sprops.Prop[i]
+		if props.Required {
+			return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
+		}
+	}
+	return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
+}
+
+// Returns the index in the struct for the named field, as well as the parsed tag properties.
+func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
+	i, ok := sprops.decoderOrigNames[name]
+	if ok {
+		return i, sprops.Prop[i], true
+	}
+	return -1, nil, false
+}
+
+// Consume a ':' from the input stream (if the next token is a colon),
+// returning an error if a colon is needed but not present.
+func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != ":" {
+		// Colon is optional when the field is a group or message.
+		needColon := true
+		switch props.Wire {
+		case "group":
+			needColon = false
+		case "bytes":
+			// A "bytes" field is either a message, a string, or a repeated field;
+			// those three become *T, *string and []T respectively, so we can check for
+			// this field being a pointer to a non-string.
+			if typ.Kind() == reflect.Ptr {
+				// *T or *string
+				if typ.Elem().Kind() == reflect.String {
+					break
+				}
+			} else if typ.Kind() == reflect.Slice {
+				// []T or []*T
+				if typ.Elem().Kind() != reflect.Ptr {
+					break
+				}
+			} else if typ.Kind() == reflect.String {
+				// The proto3 exception is for a string field,
+				// which requires a colon.
+				break
+			}
+			needColon = false
+		}
+		if needColon {
+			return p.errorf("expected ':', found %q", tok.value)
+		}
+		p.back()
+	}
+	return nil
+}
+
+func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
+	st := sv.Type()
+	sprops := GetProperties(st)
+	reqCount := sprops.reqCount
+	var reqFieldErr error
+	fieldSet := make(map[string]bool)
+	// A struct is a sequence of "name: value", terminated by one of
+	// '>' or '}', or the end of the input.  A name may also be
+	// "[extension]" or "[type/url]".
+	//
+	// The whole struct can also be an expanded Any message, like:
+	// [type/url] < ... struct contents ... >
+	for {
+		tok := p.next()
+		if tok.err != nil {
+			return tok.err
+		}
+		if tok.value == terminator {
+			break
+		}
+		if tok.value == "[" {
+			// Looks like an extension or an Any.
+			//
+			// TODO: Check whether we need to handle
+			// namespace rooted names (e.g. ".something.Foo").
+			extName, err := p.consumeExtName()
+			if err != nil {
+				return err
+			}
+
+			if s := strings.LastIndex(extName, "/"); s >= 0 {
+				// If it contains a slash, it's an Any type URL.
+				messageName := extName[s+1:]
+				mt := MessageType(messageName)
+				if mt == nil {
+					return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
+				}
+				tok = p.next()
+				if tok.err != nil {
+					return tok.err
+				}
+				// consume an optional colon
+				if tok.value == ":" {
+					tok = p.next()
+					if tok.err != nil {
+						return tok.err
+					}
+				}
+				var terminator string
+				switch tok.value {
+				case "<":
+					terminator = ">"
+				case "{":
+					terminator = "}"
+				default:
+					return p.errorf("expected '{' or '<', found %q", tok.value)
+				}
+				v := reflect.New(mt.Elem())
+				if pe := p.readStruct(v.Elem(), terminator); pe != nil {
+					return pe
+				}
+				b, err := Marshal(v.Interface().(Message))
+				if err != nil {
+					return p.errorf("failed to marshal message of type %q: %v", messageName, err)
+				}
+				if fieldSet["type_url"] {
+					return p.errorf(anyRepeatedlyUnpacked, "type_url")
+				}
+				if fieldSet["value"] {
+					return p.errorf(anyRepeatedlyUnpacked, "value")
+				}
+				sv.FieldByName("TypeUrl").SetString(extName)
+				sv.FieldByName("Value").SetBytes(b)
+				fieldSet["type_url"] = true
+				fieldSet["value"] = true
+				continue
+			}
+
+			var desc *ExtensionDesc
+			// This could be faster, but it's functional.
+			// TODO: Do something smarter than a linear scan.
+			for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
+				if d.Name == extName {
+					desc = d
+					break
+				}
+			}
+			if desc == nil {
+				return p.errorf("unrecognized extension %q", extName)
+			}
+
+			props := &Properties{}
+			props.Parse(desc.Tag)
+
+			typ := reflect.TypeOf(desc.ExtensionType)
+			if err := p.checkForColon(props, typ); err != nil {
+				return err
+			}
+
+			rep := desc.repeated()
+
+			// Read the extension structure, and set it in
+			// the value we're constructing.
+			var ext reflect.Value
+			if !rep {
+				ext = reflect.New(typ).Elem()
+			} else {
+				ext = reflect.New(typ.Elem()).Elem()
+			}
+			if err := p.readAny(ext, props); err != nil {
+				if _, ok := err.(*RequiredNotSetError); !ok {
+					return err
+				}
+				reqFieldErr = err
+			}
+			ep := sv.Addr().Interface().(Message)
+			if !rep {
+				SetExtension(ep, desc, ext.Interface())
+			} else {
+				old, err := GetExtension(ep, desc)
+				var sl reflect.Value
+				if err == nil {
+					sl = reflect.ValueOf(old) // existing slice
+				} else {
+					sl = reflect.MakeSlice(typ, 0, 1)
+				}
+				sl = reflect.Append(sl, ext)
+				SetExtension(ep, desc, sl.Interface())
+			}
+			if err := p.consumeOptionalSeparator(); err != nil {
+				return err
+			}
+			continue
+		}
+
+		// This is a normal, non-extension field.
+		name := tok.value
+		var dst reflect.Value
+		fi, props, ok := structFieldByName(sprops, name)
+		if ok {
+			dst = sv.Field(fi)
+		} else if oop, ok := sprops.OneofTypes[name]; ok {
+			// It is a oneof.
+			props = oop.Prop
+			nv := reflect.New(oop.Type.Elem())
+			dst = nv.Elem().Field(0)
+			field := sv.Field(oop.Field)
+			if !field.IsNil() {
+				return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name)
+			}
+			field.Set(nv)
+		}
+		if !dst.IsValid() {
+			return p.errorf("unknown field name %q in %v", name, st)
+		}
+
+		if dst.Kind() == reflect.Map {
+			// Consume any colon.
+			if err := p.checkForColon(props, dst.Type()); err != nil {
+				return err
+			}
+
+			// Construct the map if it doesn't already exist.
+			if dst.IsNil() {
+				dst.Set(reflect.MakeMap(dst.Type()))
+			}
+			key := reflect.New(dst.Type().Key()).Elem()
+			val := reflect.New(dst.Type().Elem()).Elem()
+
+			// The map entry should be this sequence of tokens:
+			//	< key : KEY value : VALUE >
+			// However, implementations may omit key or value, and technically
+			// we should support them in any order.  See b/28924776 for a time
+			// this went wrong.
+
+			tok := p.next()
+			var terminator string
+			switch tok.value {
+			case "<":
+				terminator = ">"
+			case "{":
+				terminator = "}"
+			default:
+				return p.errorf("expected '{' or '<', found %q", tok.value)
+			}
+			for {
+				tok := p.next()
+				if tok.err != nil {
+					return tok.err
+				}
+				if tok.value == terminator {
+					break
+				}
+				switch tok.value {
+				case "key":
+					if err := p.consumeToken(":"); err != nil {
+						return err
+					}
+					if err := p.readAny(key, props.MapKeyProp); err != nil {
+						return err
+					}
+					if err := p.consumeOptionalSeparator(); err != nil {
+						return err
+					}
+				case "value":
+					if err := p.checkForColon(props.MapValProp, dst.Type().Elem()); err != nil {
+						return err
+					}
+					if err := p.readAny(val, props.MapValProp); err != nil {
+						return err
+					}
+					if err := p.consumeOptionalSeparator(); err != nil {
+						return err
+					}
+				default:
+					p.back()
+					return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
+				}
+			}
+
+			dst.SetMapIndex(key, val)
+			continue
+		}
+
+		// Check that it's not already set if it's not a repeated field.
+		if !props.Repeated && fieldSet[name] {
+			return p.errorf("non-repeated field %q was repeated", name)
+		}
+
+		if err := p.checkForColon(props, dst.Type()); err != nil {
+			return err
+		}
+
+		// Parse into the field.
+		fieldSet[name] = true
+		if err := p.readAny(dst, props); err != nil {
+			if _, ok := err.(*RequiredNotSetError); !ok {
+				return err
+			}
+			reqFieldErr = err
+		}
+		if props.Required {
+			reqCount--
+		}
+
+		if err := p.consumeOptionalSeparator(); err != nil {
+			return err
+		}
+
+	}
+
+	if reqCount > 0 {
+		return p.missingRequiredFieldError(sv)
+	}
+	return reqFieldErr
+}
+
+// consumeExtName consumes extension name or expanded Any type URL and the
+// following ']'. It returns the name or URL consumed.
+func (p *textParser) consumeExtName() (string, error) {
+	tok := p.next()
+	if tok.err != nil {
+		return "", tok.err
+	}
+
+	// If extension name or type url is quoted, it's a single token.
+	if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
+		name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
+		if err != nil {
+			return "", err
+		}
+		return name, p.consumeToken("]")
+	}
+
+	// Consume everything up to "]"
+	var parts []string
+	for tok.value != "]" {
+		parts = append(parts, tok.value)
+		tok = p.next()
+		if tok.err != nil {
+			return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
+		}
+		if p.done && tok.value != "]" {
+			return "", p.errorf("unclosed type_url or extension name")
+		}
+	}
+	return strings.Join(parts, ""), nil
+}
+
+// consumeOptionalSeparator consumes an optional semicolon or comma.
+// It is used in readStruct to provide backward compatibility.
+func (p *textParser) consumeOptionalSeparator() error {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != ";" && tok.value != "," {
+		p.back()
+	}
+	return nil
+}
+
+func (p *textParser) readAny(v reflect.Value, props *Properties) error {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value == "" {
+		return p.errorf("unexpected EOF")
+	}
+
+	switch fv := v; fv.Kind() {
+	case reflect.Slice:
+		at := v.Type()
+		if at.Elem().Kind() == reflect.Uint8 {
+			// Special case for []byte
+			if tok.value[0] != '"' && tok.value[0] != '\'' {
+				// Deliberately written out here, as the error after
+				// this switch statement would write "invalid []byte: ...",
+				// which is not as user-friendly.
+				return p.errorf("invalid string: %v", tok.value)
+			}
+			bytes := []byte(tok.unquoted)
+			fv.Set(reflect.ValueOf(bytes))
+			return nil
+		}
+		// Repeated field.
+		if tok.value == "[" {
+			// Repeated field with list notation, like [1,2,3].
+			for {
+				fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
+				err := p.readAny(fv.Index(fv.Len()-1), props)
+				if err != nil {
+					return err
+				}
+				tok := p.next()
+				if tok.err != nil {
+					return tok.err
+				}
+				if tok.value == "]" {
+					break
+				}
+				if tok.value != "," {
+					return p.errorf("Expected ']' or ',' found %q", tok.value)
+				}
+			}
+			return nil
+		}
+		// One value of the repeated field.
+		p.back()
+		fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
+		return p.readAny(fv.Index(fv.Len()-1), props)
+	case reflect.Bool:
+		// true/1/t/True or false/f/0/False.
+		switch tok.value {
+		case "true", "1", "t", "True":
+			fv.SetBool(true)
+			return nil
+		case "false", "0", "f", "False":
+			fv.SetBool(false)
+			return nil
+		}
+	case reflect.Float32, reflect.Float64:
+		v := tok.value
+		// Ignore 'f' for compatibility with output generated by C++, but don't
+		// remove 'f' when the value is "-inf" or "inf".
+		if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
+			v = v[:len(v)-1]
+		}
+		if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
+			fv.SetFloat(f)
+			return nil
+		}
+	case reflect.Int32:
+		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
+			fv.SetInt(x)
+			return nil
+		}
+
+		if len(props.Enum) == 0 {
+			break
+		}
+		m, ok := enumValueMaps[props.Enum]
+		if !ok {
+			break
+		}
+		x, ok := m[tok.value]
+		if !ok {
+			break
+		}
+		fv.SetInt(int64(x))
+		return nil
+	case reflect.Int64:
+		if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
+			fv.SetInt(x)
+			return nil
+		}
+
+	case reflect.Ptr:
+		// A basic field (indirected through pointer), or a repeated message/group
+		p.back()
+		fv.Set(reflect.New(fv.Type().Elem()))
+		return p.readAny(fv.Elem(), props)
+	case reflect.String:
+		if tok.value[0] == '"' || tok.value[0] == '\'' {
+			fv.SetString(tok.unquoted)
+			return nil
+		}
+	case reflect.Struct:
+		var terminator string
+		switch tok.value {
+		case "{":
+			terminator = "}"
+		case "<":
+			terminator = ">"
+		default:
+			return p.errorf("expected '{' or '<', found %q", tok.value)
+		}
+		// TODO: Handle nested messages which implement encoding.TextUnmarshaler.
+		return p.readStruct(fv, terminator)
+	case reflect.Uint32:
+		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
+			fv.SetUint(uint64(x))
+			return nil
+		}
+	case reflect.Uint64:
+		if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
+			fv.SetUint(x)
+			return nil
+		}
+	}
+	return p.errorf("invalid %v: %v", v.Type(), tok.value)
+}
+
+// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
+// before starting to unmarshal, so any existing data in pb is always removed.
+// If a required field is not set and no other error occurs,
+// UnmarshalText returns *RequiredNotSetError.
+func UnmarshalText(s string, pb Message) error {
+	if um, ok := pb.(encoding.TextUnmarshaler); ok {
+		return um.UnmarshalText([]byte(s))
+	}
+	pb.Reset()
+	v := reflect.ValueOf(pb)
+	return newTextParser(s).readStruct(v.Elem(), "")
+}
diff --git a/vendor/github.com/golang/protobuf/proto/wire.go b/vendor/github.com/golang/protobuf/proto/wire.go
deleted file mode 100644
index d7c28da..0000000
--- a/vendor/github.com/golang/protobuf/proto/wire.go
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	protoV2 "google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/runtime/protoiface"
-)
-
-// Size returns the size in bytes of the wire-format encoding of m.
-func Size(m Message) int {
-	if m == nil {
-		return 0
-	}
-	mi := MessageV2(m)
-	return protoV2.Size(mi)
-}
-
-// Marshal returns the wire-format encoding of m.
-func Marshal(m Message) ([]byte, error) {
-	b, err := marshalAppend(nil, m, false)
-	if b == nil {
-		b = zeroBytes
-	}
-	return b, err
-}
-
-var zeroBytes = make([]byte, 0, 0)
-
-func marshalAppend(buf []byte, m Message, deterministic bool) ([]byte, error) {
-	if m == nil {
-		return nil, ErrNil
-	}
-	mi := MessageV2(m)
-	nbuf, err := protoV2.MarshalOptions{
-		Deterministic: deterministic,
-		AllowPartial:  true,
-	}.MarshalAppend(buf, mi)
-	if err != nil {
-		return buf, err
-	}
-	if len(buf) == len(nbuf) {
-		if !mi.ProtoReflect().IsValid() {
-			return buf, ErrNil
-		}
-	}
-	return nbuf, checkRequiredNotSet(mi)
-}
-
-// Unmarshal parses a wire-format message in b and places the decoded results in m.
-//
-// Unmarshal resets m before starting to unmarshal, so any existing data in m is always
-// removed. Use UnmarshalMerge to preserve and append to existing data.
-func Unmarshal(b []byte, m Message) error {
-	m.Reset()
-	return UnmarshalMerge(b, m)
-}
-
-// UnmarshalMerge parses a wire-format message in b and places the decoded results in m.
-func UnmarshalMerge(b []byte, m Message) error {
-	mi := MessageV2(m)
-	out, err := protoV2.UnmarshalOptions{
-		AllowPartial: true,
-		Merge:        true,
-	}.UnmarshalState(protoiface.UnmarshalInput{
-		Buf:     b,
-		Message: mi.ProtoReflect(),
-	})
-	if err != nil {
-		return err
-	}
-	if out.Flags&protoiface.UnmarshalInitialized > 0 {
-		return nil
-	}
-	return checkRequiredNotSet(mi)
-}
diff --git a/vendor/github.com/golang/protobuf/proto/wrappers.go b/vendor/github.com/golang/protobuf/proto/wrappers.go
deleted file mode 100644
index 398e348..0000000
--- a/vendor/github.com/golang/protobuf/proto/wrappers.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-// Bool stores v in a new bool value and returns a pointer to it.
-func Bool(v bool) *bool { return &v }
-
-// Int stores v in a new int32 value and returns a pointer to it.
-//
-// Deprecated: Use Int32 instead.
-func Int(v int) *int32 { return Int32(int32(v)) }
-
-// Int32 stores v in a new int32 value and returns a pointer to it.
-func Int32(v int32) *int32 { return &v }
-
-// Int64 stores v in a new int64 value and returns a pointer to it.
-func Int64(v int64) *int64 { return &v }
-
-// Uint32 stores v in a new uint32 value and returns a pointer to it.
-func Uint32(v uint32) *uint32 { return &v }
-
-// Uint64 stores v in a new uint64 value and returns a pointer to it.
-func Uint64(v uint64) *uint64 { return &v }
-
-// Float32 stores v in a new float32 value and returns a pointer to it.
-func Float32(v float32) *float32 { return &v }
-
-// Float64 stores v in a new float64 value and returns a pointer to it.
-func Float64(v float64) *float64 { return &v }
-
-// String stores v in a new string value and returns a pointer to it.
-func String(v string) *string { return &v }
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
index 63dc057..1ded05b 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
@@ -1,200 +1,2887 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
+// source: google/protobuf/descriptor.proto
 
 package descriptor
 
 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
 )
 
-// Symbols defined in public import of google/protobuf/descriptor.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
 
-type FieldDescriptorProto_Type = descriptorpb.FieldDescriptorProto_Type
+// 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.ProtoPackageIsVersion3 // please upgrade the proto package
 
-const FieldDescriptorProto_TYPE_DOUBLE = descriptorpb.FieldDescriptorProto_TYPE_DOUBLE
-const FieldDescriptorProto_TYPE_FLOAT = descriptorpb.FieldDescriptorProto_TYPE_FLOAT
-const FieldDescriptorProto_TYPE_INT64 = descriptorpb.FieldDescriptorProto_TYPE_INT64
-const FieldDescriptorProto_TYPE_UINT64 = descriptorpb.FieldDescriptorProto_TYPE_UINT64
-const FieldDescriptorProto_TYPE_INT32 = descriptorpb.FieldDescriptorProto_TYPE_INT32
-const FieldDescriptorProto_TYPE_FIXED64 = descriptorpb.FieldDescriptorProto_TYPE_FIXED64
-const FieldDescriptorProto_TYPE_FIXED32 = descriptorpb.FieldDescriptorProto_TYPE_FIXED32
-const FieldDescriptorProto_TYPE_BOOL = descriptorpb.FieldDescriptorProto_TYPE_BOOL
-const FieldDescriptorProto_TYPE_STRING = descriptorpb.FieldDescriptorProto_TYPE_STRING
-const FieldDescriptorProto_TYPE_GROUP = descriptorpb.FieldDescriptorProto_TYPE_GROUP
-const FieldDescriptorProto_TYPE_MESSAGE = descriptorpb.FieldDescriptorProto_TYPE_MESSAGE
-const FieldDescriptorProto_TYPE_BYTES = descriptorpb.FieldDescriptorProto_TYPE_BYTES
-const FieldDescriptorProto_TYPE_UINT32 = descriptorpb.FieldDescriptorProto_TYPE_UINT32
-const FieldDescriptorProto_TYPE_ENUM = descriptorpb.FieldDescriptorProto_TYPE_ENUM
-const FieldDescriptorProto_TYPE_SFIXED32 = descriptorpb.FieldDescriptorProto_TYPE_SFIXED32
-const FieldDescriptorProto_TYPE_SFIXED64 = descriptorpb.FieldDescriptorProto_TYPE_SFIXED64
-const FieldDescriptorProto_TYPE_SINT32 = descriptorpb.FieldDescriptorProto_TYPE_SINT32
-const FieldDescriptorProto_TYPE_SINT64 = descriptorpb.FieldDescriptorProto_TYPE_SINT64
+type FieldDescriptorProto_Type int32
 
-var FieldDescriptorProto_Type_name = descriptorpb.FieldDescriptorProto_Type_name
-var FieldDescriptorProto_Type_value = descriptorpb.FieldDescriptorProto_Type_value
+const (
+	// 0 is reserved for errors.
+	// Order is weird for historical reasons.
+	FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1
+	FieldDescriptorProto_TYPE_FLOAT  FieldDescriptorProto_Type = 2
+	// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+	// negative values are likely.
+	FieldDescriptorProto_TYPE_INT64  FieldDescriptorProto_Type = 3
+	FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4
+	// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+	// negative values are likely.
+	FieldDescriptorProto_TYPE_INT32   FieldDescriptorProto_Type = 5
+	FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6
+	FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7
+	FieldDescriptorProto_TYPE_BOOL    FieldDescriptorProto_Type = 8
+	FieldDescriptorProto_TYPE_STRING  FieldDescriptorProto_Type = 9
+	// Tag-delimited aggregate.
+	// Group type is deprecated and not supported in proto3. However, Proto3
+	// implementations should still be able to parse the group wire format and
+	// treat group fields as unknown fields.
+	FieldDescriptorProto_TYPE_GROUP   FieldDescriptorProto_Type = 10
+	FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11
+	// New in version 2.
+	FieldDescriptorProto_TYPE_BYTES    FieldDescriptorProto_Type = 12
+	FieldDescriptorProto_TYPE_UINT32   FieldDescriptorProto_Type = 13
+	FieldDescriptorProto_TYPE_ENUM     FieldDescriptorProto_Type = 14
+	FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15
+	FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16
+	FieldDescriptorProto_TYPE_SINT32   FieldDescriptorProto_Type = 17
+	FieldDescriptorProto_TYPE_SINT64   FieldDescriptorProto_Type = 18
+)
 
-type FieldDescriptorProto_Label = descriptorpb.FieldDescriptorProto_Label
-
-const FieldDescriptorProto_LABEL_OPTIONAL = descriptorpb.FieldDescriptorProto_LABEL_OPTIONAL
-const FieldDescriptorProto_LABEL_REQUIRED = descriptorpb.FieldDescriptorProto_LABEL_REQUIRED
-const FieldDescriptorProto_LABEL_REPEATED = descriptorpb.FieldDescriptorProto_LABEL_REPEATED
-
-var FieldDescriptorProto_Label_name = descriptorpb.FieldDescriptorProto_Label_name
-var FieldDescriptorProto_Label_value = descriptorpb.FieldDescriptorProto_Label_value
-
-type FileOptions_OptimizeMode = descriptorpb.FileOptions_OptimizeMode
-
-const FileOptions_SPEED = descriptorpb.FileOptions_SPEED
-const FileOptions_CODE_SIZE = descriptorpb.FileOptions_CODE_SIZE
-const FileOptions_LITE_RUNTIME = descriptorpb.FileOptions_LITE_RUNTIME
-
-var FileOptions_OptimizeMode_name = descriptorpb.FileOptions_OptimizeMode_name
-var FileOptions_OptimizeMode_value = descriptorpb.FileOptions_OptimizeMode_value
-
-type FieldOptions_CType = descriptorpb.FieldOptions_CType
-
-const FieldOptions_STRING = descriptorpb.FieldOptions_STRING
-const FieldOptions_CORD = descriptorpb.FieldOptions_CORD
-const FieldOptions_STRING_PIECE = descriptorpb.FieldOptions_STRING_PIECE
-
-var FieldOptions_CType_name = descriptorpb.FieldOptions_CType_name
-var FieldOptions_CType_value = descriptorpb.FieldOptions_CType_value
-
-type FieldOptions_JSType = descriptorpb.FieldOptions_JSType
-
-const FieldOptions_JS_NORMAL = descriptorpb.FieldOptions_JS_NORMAL
-const FieldOptions_JS_STRING = descriptorpb.FieldOptions_JS_STRING
-const FieldOptions_JS_NUMBER = descriptorpb.FieldOptions_JS_NUMBER
-
-var FieldOptions_JSType_name = descriptorpb.FieldOptions_JSType_name
-var FieldOptions_JSType_value = descriptorpb.FieldOptions_JSType_value
-
-type MethodOptions_IdempotencyLevel = descriptorpb.MethodOptions_IdempotencyLevel
-
-const MethodOptions_IDEMPOTENCY_UNKNOWN = descriptorpb.MethodOptions_IDEMPOTENCY_UNKNOWN
-const MethodOptions_NO_SIDE_EFFECTS = descriptorpb.MethodOptions_NO_SIDE_EFFECTS
-const MethodOptions_IDEMPOTENT = descriptorpb.MethodOptions_IDEMPOTENT
-
-var MethodOptions_IdempotencyLevel_name = descriptorpb.MethodOptions_IdempotencyLevel_name
-var MethodOptions_IdempotencyLevel_value = descriptorpb.MethodOptions_IdempotencyLevel_value
-
-type FileDescriptorSet = descriptorpb.FileDescriptorSet
-type FileDescriptorProto = descriptorpb.FileDescriptorProto
-type DescriptorProto = descriptorpb.DescriptorProto
-type ExtensionRangeOptions = descriptorpb.ExtensionRangeOptions
-type FieldDescriptorProto = descriptorpb.FieldDescriptorProto
-type OneofDescriptorProto = descriptorpb.OneofDescriptorProto
-type EnumDescriptorProto = descriptorpb.EnumDescriptorProto
-type EnumValueDescriptorProto = descriptorpb.EnumValueDescriptorProto
-type ServiceDescriptorProto = descriptorpb.ServiceDescriptorProto
-type MethodDescriptorProto = descriptorpb.MethodDescriptorProto
-
-const Default_MethodDescriptorProto_ClientStreaming = descriptorpb.Default_MethodDescriptorProto_ClientStreaming
-const Default_MethodDescriptorProto_ServerStreaming = descriptorpb.Default_MethodDescriptorProto_ServerStreaming
-
-type FileOptions = descriptorpb.FileOptions
-
-const Default_FileOptions_JavaMultipleFiles = descriptorpb.Default_FileOptions_JavaMultipleFiles
-const Default_FileOptions_JavaStringCheckUtf8 = descriptorpb.Default_FileOptions_JavaStringCheckUtf8
-const Default_FileOptions_OptimizeFor = descriptorpb.Default_FileOptions_OptimizeFor
-const Default_FileOptions_CcGenericServices = descriptorpb.Default_FileOptions_CcGenericServices
-const Default_FileOptions_JavaGenericServices = descriptorpb.Default_FileOptions_JavaGenericServices
-const Default_FileOptions_PyGenericServices = descriptorpb.Default_FileOptions_PyGenericServices
-const Default_FileOptions_PhpGenericServices = descriptorpb.Default_FileOptions_PhpGenericServices
-const Default_FileOptions_Deprecated = descriptorpb.Default_FileOptions_Deprecated
-const Default_FileOptions_CcEnableArenas = descriptorpb.Default_FileOptions_CcEnableArenas
-
-type MessageOptions = descriptorpb.MessageOptions
-
-const Default_MessageOptions_MessageSetWireFormat = descriptorpb.Default_MessageOptions_MessageSetWireFormat
-const Default_MessageOptions_NoStandardDescriptorAccessor = descriptorpb.Default_MessageOptions_NoStandardDescriptorAccessor
-const Default_MessageOptions_Deprecated = descriptorpb.Default_MessageOptions_Deprecated
-
-type FieldOptions = descriptorpb.FieldOptions
-
-const Default_FieldOptions_Ctype = descriptorpb.Default_FieldOptions_Ctype
-const Default_FieldOptions_Jstype = descriptorpb.Default_FieldOptions_Jstype
-const Default_FieldOptions_Lazy = descriptorpb.Default_FieldOptions_Lazy
-const Default_FieldOptions_Deprecated = descriptorpb.Default_FieldOptions_Deprecated
-const Default_FieldOptions_Weak = descriptorpb.Default_FieldOptions_Weak
-
-type OneofOptions = descriptorpb.OneofOptions
-type EnumOptions = descriptorpb.EnumOptions
-
-const Default_EnumOptions_Deprecated = descriptorpb.Default_EnumOptions_Deprecated
-
-type EnumValueOptions = descriptorpb.EnumValueOptions
-
-const Default_EnumValueOptions_Deprecated = descriptorpb.Default_EnumValueOptions_Deprecated
-
-type ServiceOptions = descriptorpb.ServiceOptions
-
-const Default_ServiceOptions_Deprecated = descriptorpb.Default_ServiceOptions_Deprecated
-
-type MethodOptions = descriptorpb.MethodOptions
-
-const Default_MethodOptions_Deprecated = descriptorpb.Default_MethodOptions_Deprecated
-const Default_MethodOptions_IdempotencyLevel = descriptorpb.Default_MethodOptions_IdempotencyLevel
-
-type UninterpretedOption = descriptorpb.UninterpretedOption
-type SourceCodeInfo = descriptorpb.SourceCodeInfo
-type GeneratedCodeInfo = descriptorpb.GeneratedCodeInfo
-type DescriptorProto_ExtensionRange = descriptorpb.DescriptorProto_ExtensionRange
-type DescriptorProto_ReservedRange = descriptorpb.DescriptorProto_ReservedRange
-type EnumDescriptorProto_EnumReservedRange = descriptorpb.EnumDescriptorProto_EnumReservedRange
-type UninterpretedOption_NamePart = descriptorpb.UninterpretedOption_NamePart
-type SourceCodeInfo_Location = descriptorpb.SourceCodeInfo_Location
-type GeneratedCodeInfo_Annotation = descriptorpb.GeneratedCodeInfo_Annotation
-
-var File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawDesc = []byte{
-	0x0a, 0x44, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
-	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72,
-	0x69, 0x70, 0x74, 0x6f, 0x72, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
-	0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x40, 0x5a, 0x3e, 0x67, 0x69, 0x74, 0x68,
-	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65,
-	0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3b,
-	0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x32,
+var FieldDescriptorProto_Type_name = map[int32]string{
+	1:  "TYPE_DOUBLE",
+	2:  "TYPE_FLOAT",
+	3:  "TYPE_INT64",
+	4:  "TYPE_UINT64",
+	5:  "TYPE_INT32",
+	6:  "TYPE_FIXED64",
+	7:  "TYPE_FIXED32",
+	8:  "TYPE_BOOL",
+	9:  "TYPE_STRING",
+	10: "TYPE_GROUP",
+	11: "TYPE_MESSAGE",
+	12: "TYPE_BYTES",
+	13: "TYPE_UINT32",
+	14: "TYPE_ENUM",
+	15: "TYPE_SFIXED32",
+	16: "TYPE_SFIXED64",
+	17: "TYPE_SINT32",
+	18: "TYPE_SINT64",
 }
 
-var file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
+var FieldDescriptorProto_Type_value = map[string]int32{
+	"TYPE_DOUBLE":   1,
+	"TYPE_FLOAT":    2,
+	"TYPE_INT64":    3,
+	"TYPE_UINT64":   4,
+	"TYPE_INT32":    5,
+	"TYPE_FIXED64":  6,
+	"TYPE_FIXED32":  7,
+	"TYPE_BOOL":     8,
+	"TYPE_STRING":   9,
+	"TYPE_GROUP":    10,
+	"TYPE_MESSAGE":  11,
+	"TYPE_BYTES":    12,
+	"TYPE_UINT32":   13,
+	"TYPE_ENUM":     14,
+	"TYPE_SFIXED32": 15,
+	"TYPE_SFIXED64": 16,
+	"TYPE_SINT32":   17,
+	"TYPE_SINT64":   18,
 }
 
-func init() { file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_init() }
-func file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_init() {
-	if File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto != nil {
-		return
+func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type {
+	p := new(FieldDescriptorProto_Type)
+	*p = x
+	return p
+}
+
+func (x FieldDescriptorProto_Type) String() string {
+	return proto.EnumName(FieldDescriptorProto_Type_name, int32(x))
+}
+
+func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type")
+	if err != nil {
+		return err
 	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   0,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes,
-		DependencyIndexes: file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_depIdxs,
-	}.Build()
-	File_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto = out.File
-	file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_rawDesc = nil
-	file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_goTypes = nil
-	file_github_com_golang_protobuf_protoc_gen_go_descriptor_descriptor_proto_depIdxs = nil
+	*x = FieldDescriptorProto_Type(value)
+	return nil
+}
+
+func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{4, 0}
+}
+
+type FieldDescriptorProto_Label int32
+
+const (
+	// 0 is reserved for errors
+	FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1
+	FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2
+	FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3
+)
+
+var FieldDescriptorProto_Label_name = map[int32]string{
+	1: "LABEL_OPTIONAL",
+	2: "LABEL_REQUIRED",
+	3: "LABEL_REPEATED",
+}
+
+var FieldDescriptorProto_Label_value = map[string]int32{
+	"LABEL_OPTIONAL": 1,
+	"LABEL_REQUIRED": 2,
+	"LABEL_REPEATED": 3,
+}
+
+func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label {
+	p := new(FieldDescriptorProto_Label)
+	*p = x
+	return p
+}
+
+func (x FieldDescriptorProto_Label) String() string {
+	return proto.EnumName(FieldDescriptorProto_Label_name, int32(x))
+}
+
+func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label")
+	if err != nil {
+		return err
+	}
+	*x = FieldDescriptorProto_Label(value)
+	return nil
+}
+
+func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{4, 1}
+}
+
+// Generated classes can be optimized for speed or code size.
+type FileOptions_OptimizeMode int32
+
+const (
+	FileOptions_SPEED FileOptions_OptimizeMode = 1
+	// etc.
+	FileOptions_CODE_SIZE    FileOptions_OptimizeMode = 2
+	FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3
+)
+
+var FileOptions_OptimizeMode_name = map[int32]string{
+	1: "SPEED",
+	2: "CODE_SIZE",
+	3: "LITE_RUNTIME",
+}
+
+var FileOptions_OptimizeMode_value = map[string]int32{
+	"SPEED":        1,
+	"CODE_SIZE":    2,
+	"LITE_RUNTIME": 3,
+}
+
+func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode {
+	p := new(FileOptions_OptimizeMode)
+	*p = x
+	return p
+}
+
+func (x FileOptions_OptimizeMode) String() string {
+	return proto.EnumName(FileOptions_OptimizeMode_name, int32(x))
+}
+
+func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode")
+	if err != nil {
+		return err
+	}
+	*x = FileOptions_OptimizeMode(value)
+	return nil
+}
+
+func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{10, 0}
+}
+
+type FieldOptions_CType int32
+
+const (
+	// Default mode.
+	FieldOptions_STRING       FieldOptions_CType = 0
+	FieldOptions_CORD         FieldOptions_CType = 1
+	FieldOptions_STRING_PIECE FieldOptions_CType = 2
+)
+
+var FieldOptions_CType_name = map[int32]string{
+	0: "STRING",
+	1: "CORD",
+	2: "STRING_PIECE",
+}
+
+var FieldOptions_CType_value = map[string]int32{
+	"STRING":       0,
+	"CORD":         1,
+	"STRING_PIECE": 2,
+}
+
+func (x FieldOptions_CType) Enum() *FieldOptions_CType {
+	p := new(FieldOptions_CType)
+	*p = x
+	return p
+}
+
+func (x FieldOptions_CType) String() string {
+	return proto.EnumName(FieldOptions_CType_name, int32(x))
+}
+
+func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType")
+	if err != nil {
+		return err
+	}
+	*x = FieldOptions_CType(value)
+	return nil
+}
+
+func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{12, 0}
+}
+
+type FieldOptions_JSType int32
+
+const (
+	// Use the default type.
+	FieldOptions_JS_NORMAL FieldOptions_JSType = 0
+	// Use JavaScript strings.
+	FieldOptions_JS_STRING FieldOptions_JSType = 1
+	// Use JavaScript numbers.
+	FieldOptions_JS_NUMBER FieldOptions_JSType = 2
+)
+
+var FieldOptions_JSType_name = map[int32]string{
+	0: "JS_NORMAL",
+	1: "JS_STRING",
+	2: "JS_NUMBER",
+}
+
+var FieldOptions_JSType_value = map[string]int32{
+	"JS_NORMAL": 0,
+	"JS_STRING": 1,
+	"JS_NUMBER": 2,
+}
+
+func (x FieldOptions_JSType) Enum() *FieldOptions_JSType {
+	p := new(FieldOptions_JSType)
+	*p = x
+	return p
+}
+
+func (x FieldOptions_JSType) String() string {
+	return proto.EnumName(FieldOptions_JSType_name, int32(x))
+}
+
+func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(FieldOptions_JSType_value, data, "FieldOptions_JSType")
+	if err != nil {
+		return err
+	}
+	*x = FieldOptions_JSType(value)
+	return nil
+}
+
+func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{12, 1}
+}
+
+// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
+// or neither? HTTP based RPC implementation may choose GET verb for safe
+// methods, and PUT verb for idempotent methods instead of the default POST.
+type MethodOptions_IdempotencyLevel int32
+
+const (
+	MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0
+	MethodOptions_NO_SIDE_EFFECTS     MethodOptions_IdempotencyLevel = 1
+	MethodOptions_IDEMPOTENT          MethodOptions_IdempotencyLevel = 2
+)
+
+var MethodOptions_IdempotencyLevel_name = map[int32]string{
+	0: "IDEMPOTENCY_UNKNOWN",
+	1: "NO_SIDE_EFFECTS",
+	2: "IDEMPOTENT",
+}
+
+var MethodOptions_IdempotencyLevel_value = map[string]int32{
+	"IDEMPOTENCY_UNKNOWN": 0,
+	"NO_SIDE_EFFECTS":     1,
+	"IDEMPOTENT":          2,
+}
+
+func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel {
+	p := new(MethodOptions_IdempotencyLevel)
+	*p = x
+	return p
+}
+
+func (x MethodOptions_IdempotencyLevel) String() string {
+	return proto.EnumName(MethodOptions_IdempotencyLevel_name, int32(x))
+}
+
+func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(MethodOptions_IdempotencyLevel_value, data, "MethodOptions_IdempotencyLevel")
+	if err != nil {
+		return err
+	}
+	*x = MethodOptions_IdempotencyLevel(value)
+	return nil
+}
+
+func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{17, 0}
+}
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+type FileDescriptorSet struct {
+	File                 []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
+	XXX_unrecognized     []byte                 `json:"-"`
+	XXX_sizecache        int32                  `json:"-"`
+}
+
+func (m *FileDescriptorSet) Reset()         { *m = FileDescriptorSet{} }
+func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) }
+func (*FileDescriptorSet) ProtoMessage()    {}
+func (*FileDescriptorSet) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{0}
+}
+
+func (m *FileDescriptorSet) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FileDescriptorSet.Unmarshal(m, b)
+}
+func (m *FileDescriptorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FileDescriptorSet.Marshal(b, m, deterministic)
+}
+func (m *FileDescriptorSet) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FileDescriptorSet.Merge(m, src)
+}
+func (m *FileDescriptorSet) XXX_Size() int {
+	return xxx_messageInfo_FileDescriptorSet.Size(m)
+}
+func (m *FileDescriptorSet) XXX_DiscardUnknown() {
+	xxx_messageInfo_FileDescriptorSet.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FileDescriptorSet proto.InternalMessageInfo
+
+func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto {
+	if m != nil {
+		return m.File
+	}
+	return nil
+}
+
+// Describes a complete .proto file.
+type FileDescriptorProto struct {
+	Name    *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"`
+	// Names of files imported by this file.
+	Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"`
+	// Indexes of the public imported files in the dependency list above.
+	PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"`
+	// Indexes of the weak imported files in the dependency list.
+	// For Google-internal migration only. Do not use.
+	WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
+	// All top-level definitions in this file.
+	MessageType []*DescriptorProto        `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
+	EnumType    []*EnumDescriptorProto    `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
+	Service     []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"`
+	Extension   []*FieldDescriptorProto   `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"`
+	Options     *FileOptions              `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
+	// This field contains optional information about the original source code.
+	// You may safely remove this entire field without harming runtime
+	// functionality of the descriptors -- the information is needed only by
+	// development tools.
+	SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"`
+	// The syntax of the proto file.
+	// The supported values are "proto2" and "proto3".
+	Syntax               *string  `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *FileDescriptorProto) Reset()         { *m = FileDescriptorProto{} }
+func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*FileDescriptorProto) ProtoMessage()    {}
+func (*FileDescriptorProto) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{1}
+}
+
+func (m *FileDescriptorProto) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FileDescriptorProto.Unmarshal(m, b)
+}
+func (m *FileDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FileDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *FileDescriptorProto) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FileDescriptorProto.Merge(m, src)
+}
+func (m *FileDescriptorProto) XXX_Size() int {
+	return xxx_messageInfo_FileDescriptorProto.Size(m)
+}
+func (m *FileDescriptorProto) XXX_DiscardUnknown() {
+	xxx_messageInfo_FileDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FileDescriptorProto proto.InternalMessageInfo
+
+func (m *FileDescriptorProto) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *FileDescriptorProto) GetPackage() string {
+	if m != nil && m.Package != nil {
+		return *m.Package
+	}
+	return ""
+}
+
+func (m *FileDescriptorProto) GetDependency() []string {
+	if m != nil {
+		return m.Dependency
+	}
+	return nil
+}
+
+func (m *FileDescriptorProto) GetPublicDependency() []int32 {
+	if m != nil {
+		return m.PublicDependency
+	}
+	return nil
+}
+
+func (m *FileDescriptorProto) GetWeakDependency() []int32 {
+	if m != nil {
+		return m.WeakDependency
+	}
+	return nil
+}
+
+func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto {
+	if m != nil {
+		return m.MessageType
+	}
+	return nil
+}
+
+func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto {
+	if m != nil {
+		return m.EnumType
+	}
+	return nil
+}
+
+func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto {
+	if m != nil {
+		return m.Service
+	}
+	return nil
+}
+
+func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto {
+	if m != nil {
+		return m.Extension
+	}
+	return nil
+}
+
+func (m *FileDescriptorProto) GetOptions() *FileOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
+func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo {
+	if m != nil {
+		return m.SourceCodeInfo
+	}
+	return nil
+}
+
+func (m *FileDescriptorProto) GetSyntax() string {
+	if m != nil && m.Syntax != nil {
+		return *m.Syntax
+	}
+	return ""
+}
+
+// Describes a message type.
+type DescriptorProto struct {
+	Name           *string                           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Field          []*FieldDescriptorProto           `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
+	Extension      []*FieldDescriptorProto           `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"`
+	NestedType     []*DescriptorProto                `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"`
+	EnumType       []*EnumDescriptorProto            `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
+	ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"`
+	OneofDecl      []*OneofDescriptorProto           `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"`
+	Options        *MessageOptions                   `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"`
+	ReservedRange  []*DescriptorProto_ReservedRange  `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
+	// Reserved field names, which may not be used by fields in the same message.
+	// A given name may only be reserved once.
+	ReservedName         []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DescriptorProto) Reset()         { *m = DescriptorProto{} }
+func (m *DescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*DescriptorProto) ProtoMessage()    {}
+func (*DescriptorProto) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{2}
+}
+
+func (m *DescriptorProto) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DescriptorProto.Unmarshal(m, b)
+}
+func (m *DescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *DescriptorProto) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DescriptorProto.Merge(m, src)
+}
+func (m *DescriptorProto) XXX_Size() int {
+	return xxx_messageInfo_DescriptorProto.Size(m)
+}
+func (m *DescriptorProto) XXX_DiscardUnknown() {
+	xxx_messageInfo_DescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DescriptorProto proto.InternalMessageInfo
+
+func (m *DescriptorProto) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *DescriptorProto) GetField() []*FieldDescriptorProto {
+	if m != nil {
+		return m.Field
+	}
+	return nil
+}
+
+func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto {
+	if m != nil {
+		return m.Extension
+	}
+	return nil
+}
+
+func (m *DescriptorProto) GetNestedType() []*DescriptorProto {
+	if m != nil {
+		return m.NestedType
+	}
+	return nil
+}
+
+func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto {
+	if m != nil {
+		return m.EnumType
+	}
+	return nil
+}
+
+func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange {
+	if m != nil {
+		return m.ExtensionRange
+	}
+	return nil
+}
+
+func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto {
+	if m != nil {
+		return m.OneofDecl
+	}
+	return nil
+}
+
+func (m *DescriptorProto) GetOptions() *MessageOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
+func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange {
+	if m != nil {
+		return m.ReservedRange
+	}
+	return nil
+}
+
+func (m *DescriptorProto) GetReservedName() []string {
+	if m != nil {
+		return m.ReservedName
+	}
+	return nil
+}
+
+type DescriptorProto_ExtensionRange struct {
+	Start                *int32                 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
+	End                  *int32                 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+	Options              *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
+	XXX_unrecognized     []byte                 `json:"-"`
+	XXX_sizecache        int32                  `json:"-"`
+}
+
+func (m *DescriptorProto_ExtensionRange) Reset()         { *m = DescriptorProto_ExtensionRange{} }
+func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) }
+func (*DescriptorProto_ExtensionRange) ProtoMessage()    {}
+func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{2, 0}
+}
+
+func (m *DescriptorProto_ExtensionRange) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DescriptorProto_ExtensionRange.Unmarshal(m, b)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DescriptorProto_ExtensionRange.Marshal(b, m, deterministic)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DescriptorProto_ExtensionRange.Merge(m, src)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_Size() int {
+	return xxx_messageInfo_DescriptorProto_ExtensionRange.Size(m)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_DiscardUnknown() {
+	xxx_messageInfo_DescriptorProto_ExtensionRange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DescriptorProto_ExtensionRange proto.InternalMessageInfo
+
+func (m *DescriptorProto_ExtensionRange) GetStart() int32 {
+	if m != nil && m.Start != nil {
+		return *m.Start
+	}
+	return 0
+}
+
+func (m *DescriptorProto_ExtensionRange) GetEnd() int32 {
+	if m != nil && m.End != nil {
+		return *m.End
+	}
+	return 0
+}
+
+func (m *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
+// Range of reserved tag numbers. Reserved tag numbers may not be used by
+// fields or extension ranges in the same message. Reserved ranges may
+// not overlap.
+type DescriptorProto_ReservedRange struct {
+	Start                *int32   `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
+	End                  *int32   `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DescriptorProto_ReservedRange) Reset()         { *m = DescriptorProto_ReservedRange{} }
+func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) }
+func (*DescriptorProto_ReservedRange) ProtoMessage()    {}
+func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{2, 1}
+}
+
+func (m *DescriptorProto_ReservedRange) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DescriptorProto_ReservedRange.Unmarshal(m, b)
+}
+func (m *DescriptorProto_ReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DescriptorProto_ReservedRange.Marshal(b, m, deterministic)
+}
+func (m *DescriptorProto_ReservedRange) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DescriptorProto_ReservedRange.Merge(m, src)
+}
+func (m *DescriptorProto_ReservedRange) XXX_Size() int {
+	return xxx_messageInfo_DescriptorProto_ReservedRange.Size(m)
+}
+func (m *DescriptorProto_ReservedRange) XXX_DiscardUnknown() {
+	xxx_messageInfo_DescriptorProto_ReservedRange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DescriptorProto_ReservedRange proto.InternalMessageInfo
+
+func (m *DescriptorProto_ReservedRange) GetStart() int32 {
+	if m != nil && m.Start != nil {
+		return *m.Start
+	}
+	return 0
+}
+
+func (m *DescriptorProto_ReservedRange) GetEnd() int32 {
+	if m != nil && m.End != nil {
+		return *m.End
+	}
+	return 0
+}
+
+type ExtensionRangeOptions struct {
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *ExtensionRangeOptions) Reset()         { *m = ExtensionRangeOptions{} }
+func (m *ExtensionRangeOptions) String() string { return proto.CompactTextString(m) }
+func (*ExtensionRangeOptions) ProtoMessage()    {}
+func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{3}
+}
+
+var extRange_ExtensionRangeOptions = []proto.ExtensionRange{
+	{Start: 1000, End: 536870911},
+}
+
+func (*ExtensionRangeOptions) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_ExtensionRangeOptions
+}
+
+func (m *ExtensionRangeOptions) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ExtensionRangeOptions.Unmarshal(m, b)
+}
+func (m *ExtensionRangeOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ExtensionRangeOptions.Marshal(b, m, deterministic)
+}
+func (m *ExtensionRangeOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ExtensionRangeOptions.Merge(m, src)
+}
+func (m *ExtensionRangeOptions) XXX_Size() int {
+	return xxx_messageInfo_ExtensionRangeOptions.Size(m)
+}
+func (m *ExtensionRangeOptions) XXX_DiscardUnknown() {
+	xxx_messageInfo_ExtensionRangeOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExtensionRangeOptions proto.InternalMessageInfo
+
+func (m *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if m != nil {
+		return m.UninterpretedOption
+	}
+	return nil
+}
+
+// Describes a field within a message.
+type FieldDescriptorProto struct {
+	Name   *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Number *int32                      `protobuf:"varint,3,opt,name=number" json:"number,omitempty"`
+	Label  *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"`
+	// If type_name is set, this need not be set.  If both this and type_name
+	// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+	Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"`
+	// For message and enum types, this is the name of the type.  If the name
+	// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
+	// rules are used to find the type (i.e. first the nested types within this
+	// message are searched, then within the parent, on up to the root
+	// namespace).
+	TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
+	// For extensions, this is the name of the type being extended.  It is
+	// resolved in the same manner as type_name.
+	Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"`
+	// For numeric types, contains the original text representation of the value.
+	// For booleans, "true" or "false".
+	// For strings, contains the default text contents (not escaped in any way).
+	// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
+	// TODO(kenton):  Base-64 encode?
+	DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"`
+	// If set, gives the index of a oneof in the containing type's oneof_decl
+	// list.  This field is a member of that oneof.
+	OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"`
+	// JSON name of this field. The value is set by protocol compiler. If the
+	// user has set a "json_name" option on this field, that option's value
+	// will be used. Otherwise, it's deduced from the field's name by converting
+	// it to camelCase.
+	JsonName             *string       `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"`
+	Options              *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *FieldDescriptorProto) Reset()         { *m = FieldDescriptorProto{} }
+func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*FieldDescriptorProto) ProtoMessage()    {}
+func (*FieldDescriptorProto) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{4}
+}
+
+func (m *FieldDescriptorProto) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FieldDescriptorProto.Unmarshal(m, b)
+}
+func (m *FieldDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FieldDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *FieldDescriptorProto) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldDescriptorProto.Merge(m, src)
+}
+func (m *FieldDescriptorProto) XXX_Size() int {
+	return xxx_messageInfo_FieldDescriptorProto.Size(m)
+}
+func (m *FieldDescriptorProto) XXX_DiscardUnknown() {
+	xxx_messageInfo_FieldDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldDescriptorProto proto.InternalMessageInfo
+
+func (m *FieldDescriptorProto) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *FieldDescriptorProto) GetNumber() int32 {
+	if m != nil && m.Number != nil {
+		return *m.Number
+	}
+	return 0
+}
+
+func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label {
+	if m != nil && m.Label != nil {
+		return *m.Label
+	}
+	return FieldDescriptorProto_LABEL_OPTIONAL
+}
+
+func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return FieldDescriptorProto_TYPE_DOUBLE
+}
+
+func (m *FieldDescriptorProto) GetTypeName() string {
+	if m != nil && m.TypeName != nil {
+		return *m.TypeName
+	}
+	return ""
+}
+
+func (m *FieldDescriptorProto) GetExtendee() string {
+	if m != nil && m.Extendee != nil {
+		return *m.Extendee
+	}
+	return ""
+}
+
+func (m *FieldDescriptorProto) GetDefaultValue() string {
+	if m != nil && m.DefaultValue != nil {
+		return *m.DefaultValue
+	}
+	return ""
+}
+
+func (m *FieldDescriptorProto) GetOneofIndex() int32 {
+	if m != nil && m.OneofIndex != nil {
+		return *m.OneofIndex
+	}
+	return 0
+}
+
+func (m *FieldDescriptorProto) GetJsonName() string {
+	if m != nil && m.JsonName != nil {
+		return *m.JsonName
+	}
+	return ""
+}
+
+func (m *FieldDescriptorProto) GetOptions() *FieldOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
+// Describes a oneof.
+type OneofDescriptorProto struct {
+	Name                 *string       `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Options              *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *OneofDescriptorProto) Reset()         { *m = OneofDescriptorProto{} }
+func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*OneofDescriptorProto) ProtoMessage()    {}
+func (*OneofDescriptorProto) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{5}
+}
+
+func (m *OneofDescriptorProto) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_OneofDescriptorProto.Unmarshal(m, b)
+}
+func (m *OneofDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_OneofDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *OneofDescriptorProto) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_OneofDescriptorProto.Merge(m, src)
+}
+func (m *OneofDescriptorProto) XXX_Size() int {
+	return xxx_messageInfo_OneofDescriptorProto.Size(m)
+}
+func (m *OneofDescriptorProto) XXX_DiscardUnknown() {
+	xxx_messageInfo_OneofDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_OneofDescriptorProto proto.InternalMessageInfo
+
+func (m *OneofDescriptorProto) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *OneofDescriptorProto) GetOptions() *OneofOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
+// Describes an enum type.
+type EnumDescriptorProto struct {
+	Name    *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Value   []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
+	Options *EnumOptions                `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+	// Range of reserved numeric values. Reserved numeric values may not be used
+	// by enum values in the same enum declaration. Reserved ranges may not
+	// overlap.
+	ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
+	// Reserved enum value names, which may not be reused. A given name may only
+	// be reserved once.
+	ReservedName         []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EnumDescriptorProto) Reset()         { *m = EnumDescriptorProto{} }
+func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*EnumDescriptorProto) ProtoMessage()    {}
+func (*EnumDescriptorProto) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{6}
+}
+
+func (m *EnumDescriptorProto) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EnumDescriptorProto.Unmarshal(m, b)
+}
+func (m *EnumDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EnumDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *EnumDescriptorProto) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EnumDescriptorProto.Merge(m, src)
+}
+func (m *EnumDescriptorProto) XXX_Size() int {
+	return xxx_messageInfo_EnumDescriptorProto.Size(m)
+}
+func (m *EnumDescriptorProto) XXX_DiscardUnknown() {
+	xxx_messageInfo_EnumDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumDescriptorProto proto.InternalMessageInfo
+
+func (m *EnumDescriptorProto) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func (m *EnumDescriptorProto) GetOptions() *EnumOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
+func (m *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange {
+	if m != nil {
+		return m.ReservedRange
+	}
+	return nil
+}
+
+func (m *EnumDescriptorProto) GetReservedName() []string {
+	if m != nil {
+		return m.ReservedName
+	}
+	return nil
+}
+
+// Range of reserved numeric values. Reserved values may not be used by
+// entries in the same enum. Reserved ranges may not overlap.
+//
+// Note that this is distinct from DescriptorProto.ReservedRange in that it
+// is inclusive such that it can appropriately represent the entire int32
+// domain.
+type EnumDescriptorProto_EnumReservedRange struct {
+	Start                *int32   `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
+	End                  *int32   `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EnumDescriptorProto_EnumReservedRange) Reset()         { *m = EnumDescriptorProto_EnumReservedRange{} }
+func (m *EnumDescriptorProto_EnumReservedRange) String() string { return proto.CompactTextString(m) }
+func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage()    {}
+func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{6, 0}
+}
+
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Unmarshal(m, b)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Marshal(b, m, deterministic)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Merge(m, src)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Size() int {
+	return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Size(m)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_DiscardUnknown() {
+	xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumDescriptorProto_EnumReservedRange proto.InternalMessageInfo
+
+func (m *EnumDescriptorProto_EnumReservedRange) GetStart() int32 {
+	if m != nil && m.Start != nil {
+		return *m.Start
+	}
+	return 0
+}
+
+func (m *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 {
+	if m != nil && m.End != nil {
+		return *m.End
+	}
+	return 0
+}
+
+// Describes a value within an enum.
+type EnumValueDescriptorProto struct {
+	Name                 *string           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Number               *int32            `protobuf:"varint,2,opt,name=number" json:"number,omitempty"`
+	Options              *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *EnumValueDescriptorProto) Reset()         { *m = EnumValueDescriptorProto{} }
+func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*EnumValueDescriptorProto) ProtoMessage()    {}
+func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{7}
+}
+
+func (m *EnumValueDescriptorProto) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EnumValueDescriptorProto.Unmarshal(m, b)
+}
+func (m *EnumValueDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EnumValueDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *EnumValueDescriptorProto) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EnumValueDescriptorProto.Merge(m, src)
+}
+func (m *EnumValueDescriptorProto) XXX_Size() int {
+	return xxx_messageInfo_EnumValueDescriptorProto.Size(m)
+}
+func (m *EnumValueDescriptorProto) XXX_DiscardUnknown() {
+	xxx_messageInfo_EnumValueDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumValueDescriptorProto proto.InternalMessageInfo
+
+func (m *EnumValueDescriptorProto) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *EnumValueDescriptorProto) GetNumber() int32 {
+	if m != nil && m.Number != nil {
+		return *m.Number
+	}
+	return 0
+}
+
+func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
+// Describes a service.
+type ServiceDescriptorProto struct {
+	Name                 *string                  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Method               []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"`
+	Options              *ServiceOptions          `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
+	XXX_unrecognized     []byte                   `json:"-"`
+	XXX_sizecache        int32                    `json:"-"`
+}
+
+func (m *ServiceDescriptorProto) Reset()         { *m = ServiceDescriptorProto{} }
+func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*ServiceDescriptorProto) ProtoMessage()    {}
+func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{8}
+}
+
+func (m *ServiceDescriptorProto) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ServiceDescriptorProto.Unmarshal(m, b)
+}
+func (m *ServiceDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ServiceDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *ServiceDescriptorProto) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ServiceDescriptorProto.Merge(m, src)
+}
+func (m *ServiceDescriptorProto) XXX_Size() int {
+	return xxx_messageInfo_ServiceDescriptorProto.Size(m)
+}
+func (m *ServiceDescriptorProto) XXX_DiscardUnknown() {
+	xxx_messageInfo_ServiceDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServiceDescriptorProto proto.InternalMessageInfo
+
+func (m *ServiceDescriptorProto) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto {
+	if m != nil {
+		return m.Method
+	}
+	return nil
+}
+
+func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
+// Describes a method of a service.
+type MethodDescriptorProto struct {
+	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	// Input and output type names.  These are resolved in the same way as
+	// FieldDescriptorProto.type_name, but must refer to a message type.
+	InputType  *string        `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"`
+	OutputType *string        `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"`
+	Options    *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"`
+	// Identifies if client streams multiple client messages
+	ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"`
+	// Identifies if server streams multiple server messages
+	ServerStreaming      *bool    `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MethodDescriptorProto) Reset()         { *m = MethodDescriptorProto{} }
+func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*MethodDescriptorProto) ProtoMessage()    {}
+func (*MethodDescriptorProto) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{9}
+}
+
+func (m *MethodDescriptorProto) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MethodDescriptorProto.Unmarshal(m, b)
+}
+func (m *MethodDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MethodDescriptorProto.Marshal(b, m, deterministic)
+}
+func (m *MethodDescriptorProto) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MethodDescriptorProto.Merge(m, src)
+}
+func (m *MethodDescriptorProto) XXX_Size() int {
+	return xxx_messageInfo_MethodDescriptorProto.Size(m)
+}
+func (m *MethodDescriptorProto) XXX_DiscardUnknown() {
+	xxx_messageInfo_MethodDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MethodDescriptorProto proto.InternalMessageInfo
+
+const Default_MethodDescriptorProto_ClientStreaming bool = false
+const Default_MethodDescriptorProto_ServerStreaming bool = false
+
+func (m *MethodDescriptorProto) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *MethodDescriptorProto) GetInputType() string {
+	if m != nil && m.InputType != nil {
+		return *m.InputType
+	}
+	return ""
+}
+
+func (m *MethodDescriptorProto) GetOutputType() string {
+	if m != nil && m.OutputType != nil {
+		return *m.OutputType
+	}
+	return ""
+}
+
+func (m *MethodDescriptorProto) GetOptions() *MethodOptions {
+	if m != nil {
+		return m.Options
+	}
+	return nil
+}
+
+func (m *MethodDescriptorProto) GetClientStreaming() bool {
+	if m != nil && m.ClientStreaming != nil {
+		return *m.ClientStreaming
+	}
+	return Default_MethodDescriptorProto_ClientStreaming
+}
+
+func (m *MethodDescriptorProto) GetServerStreaming() bool {
+	if m != nil && m.ServerStreaming != nil {
+		return *m.ServerStreaming
+	}
+	return Default_MethodDescriptorProto_ServerStreaming
+}
+
+type FileOptions struct {
+	// Sets the Java package where classes generated from this .proto will be
+	// placed.  By default, the proto package is used, but this is often
+	// inappropriate because proto packages do not normally start with backwards
+	// domain names.
+	JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"`
+	// If set, all the classes from the .proto file are wrapped in a single
+	// outer class with the given name.  This applies to both Proto1
+	// (equivalent to the old "--one_java_file" option) and Proto2 (where
+	// a .proto always translates to a single class, but you may want to
+	// explicitly choose the class name).
+	JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"`
+	// If set true, then the Java code generator will generate a separate .java
+	// file for each top-level message, enum, and service defined in the .proto
+	// file.  Thus, these types will *not* be nested inside the outer class
+	// named by java_outer_classname.  However, the outer class will still be
+	// generated to contain the file's getDescriptor() method as well as any
+	// top-level extensions defined in the file.
+	JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"`
+	// This option does nothing.
+	JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"` // Deprecated: Do not use.
+	// If set true, then the Java2 code generator will generate code that
+	// throws an exception whenever an attempt is made to assign a non-UTF-8
+	// byte sequence to a string field.
+	// Message reflection will do the same.
+	// However, an extension field still accepts non-UTF-8 byte sequences.
+	// This option has no effect on when used with the lite runtime.
+	JavaStringCheckUtf8 *bool                     `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"`
+	OptimizeFor         *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"`
+	// Sets the Go package where structs generated from this .proto will be
+	// placed. If omitted, the Go package will be derived from the following:
+	//   - The basename of the package import path, if provided.
+	//   - Otherwise, the package statement in the .proto file, if present.
+	//   - Otherwise, the basename of the .proto file, without extension.
+	GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"`
+	// Should generic services be generated in each language?  "Generic" services
+	// are not specific to any particular RPC system.  They are generated by the
+	// main code generators in each language (without additional plugins).
+	// Generic services were the only kind of service generation supported by
+	// early versions of google.protobuf.
+	//
+	// Generic services are now considered deprecated in favor of using plugins
+	// that generate code specific to your particular RPC system.  Therefore,
+	// these default to false.  Old code which depends on generic services should
+	// explicitly set them to true.
+	CcGenericServices   *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
+	JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
+	PyGenericServices   *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
+	PhpGenericServices  *bool `protobuf:"varint,42,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"`
+	// Is this file deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for everything in the file, or it will be completely ignored; in the very
+	// least, this is a formalization for deprecating files.
+	Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// Enables the use of arenas for the proto messages in this file. This applies
+	// only to generated classes for C++.
+	CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=0" json:"cc_enable_arenas,omitempty"`
+	// Sets the objective c class prefix which is prepended to all objective c
+	// generated classes from this .proto. There is no default.
+	ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"`
+	// Namespace for generated classes; defaults to the package.
+	CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"`
+	// By default Swift generators will take the proto package and CamelCase it
+	// replacing '.' with underscore and use that to prefix the types/symbols
+	// defined. When this options is provided, they will use this value instead
+	// to prefix the types/symbols defined.
+	SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
+	// Sets the php class prefix which is prepended to all php generated classes
+	// from this .proto. Default is empty.
+	PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
+	// Use this option to change the namespace of php generated classes. Default
+	// is empty. When this option is empty, the package name will be used for
+	// determining the namespace.
+	PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
+	// Use this option to change the namespace of php generated metadata classes.
+	// Default is empty. When this option is empty, the proto file name will be used
+	// for determining the namespace.
+	PhpMetadataNamespace *string `protobuf:"bytes,44,opt,name=php_metadata_namespace,json=phpMetadataNamespace" json:"php_metadata_namespace,omitempty"`
+	// Use this option to change the package of ruby generated classes. Default
+	// is empty. When this option is not set, the package name will be used for
+	// determining the ruby package.
+	RubyPackage *string `protobuf:"bytes,45,opt,name=ruby_package,json=rubyPackage" json:"ruby_package,omitempty"`
+	// The parser stores options it doesn't recognize here.
+	// See the documentation for the "Options" section above.
+	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *FileOptions) Reset()         { *m = FileOptions{} }
+func (m *FileOptions) String() string { return proto.CompactTextString(m) }
+func (*FileOptions) ProtoMessage()    {}
+func (*FileOptions) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{10}
+}
+
+var extRange_FileOptions = []proto.ExtensionRange{
+	{Start: 1000, End: 536870911},
+}
+
+func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_FileOptions
+}
+
+func (m *FileOptions) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FileOptions.Unmarshal(m, b)
+}
+func (m *FileOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FileOptions.Marshal(b, m, deterministic)
+}
+func (m *FileOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FileOptions.Merge(m, src)
+}
+func (m *FileOptions) XXX_Size() int {
+	return xxx_messageInfo_FileOptions.Size(m)
+}
+func (m *FileOptions) XXX_DiscardUnknown() {
+	xxx_messageInfo_FileOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FileOptions proto.InternalMessageInfo
+
+const Default_FileOptions_JavaMultipleFiles bool = false
+const Default_FileOptions_JavaStringCheckUtf8 bool = false
+const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED
+const Default_FileOptions_CcGenericServices bool = false
+const Default_FileOptions_JavaGenericServices bool = false
+const Default_FileOptions_PyGenericServices bool = false
+const Default_FileOptions_PhpGenericServices bool = false
+const Default_FileOptions_Deprecated bool = false
+const Default_FileOptions_CcEnableArenas bool = false
+
+func (m *FileOptions) GetJavaPackage() string {
+	if m != nil && m.JavaPackage != nil {
+		return *m.JavaPackage
+	}
+	return ""
+}
+
+func (m *FileOptions) GetJavaOuterClassname() string {
+	if m != nil && m.JavaOuterClassname != nil {
+		return *m.JavaOuterClassname
+	}
+	return ""
+}
+
+func (m *FileOptions) GetJavaMultipleFiles() bool {
+	if m != nil && m.JavaMultipleFiles != nil {
+		return *m.JavaMultipleFiles
+	}
+	return Default_FileOptions_JavaMultipleFiles
+}
+
+// Deprecated: Do not use.
+func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool {
+	if m != nil && m.JavaGenerateEqualsAndHash != nil {
+		return *m.JavaGenerateEqualsAndHash
+	}
+	return false
+}
+
+func (m *FileOptions) GetJavaStringCheckUtf8() bool {
+	if m != nil && m.JavaStringCheckUtf8 != nil {
+		return *m.JavaStringCheckUtf8
+	}
+	return Default_FileOptions_JavaStringCheckUtf8
+}
+
+func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode {
+	if m != nil && m.OptimizeFor != nil {
+		return *m.OptimizeFor
+	}
+	return Default_FileOptions_OptimizeFor
+}
+
+func (m *FileOptions) GetGoPackage() string {
+	if m != nil && m.GoPackage != nil {
+		return *m.GoPackage
+	}
+	return ""
+}
+
+func (m *FileOptions) GetCcGenericServices() bool {
+	if m != nil && m.CcGenericServices != nil {
+		return *m.CcGenericServices
+	}
+	return Default_FileOptions_CcGenericServices
+}
+
+func (m *FileOptions) GetJavaGenericServices() bool {
+	if m != nil && m.JavaGenericServices != nil {
+		return *m.JavaGenericServices
+	}
+	return Default_FileOptions_JavaGenericServices
+}
+
+func (m *FileOptions) GetPyGenericServices() bool {
+	if m != nil && m.PyGenericServices != nil {
+		return *m.PyGenericServices
+	}
+	return Default_FileOptions_PyGenericServices
+}
+
+func (m *FileOptions) GetPhpGenericServices() bool {
+	if m != nil && m.PhpGenericServices != nil {
+		return *m.PhpGenericServices
+	}
+	return Default_FileOptions_PhpGenericServices
+}
+
+func (m *FileOptions) GetDeprecated() bool {
+	if m != nil && m.Deprecated != nil {
+		return *m.Deprecated
+	}
+	return Default_FileOptions_Deprecated
+}
+
+func (m *FileOptions) GetCcEnableArenas() bool {
+	if m != nil && m.CcEnableArenas != nil {
+		return *m.CcEnableArenas
+	}
+	return Default_FileOptions_CcEnableArenas
+}
+
+func (m *FileOptions) GetObjcClassPrefix() string {
+	if m != nil && m.ObjcClassPrefix != nil {
+		return *m.ObjcClassPrefix
+	}
+	return ""
+}
+
+func (m *FileOptions) GetCsharpNamespace() string {
+	if m != nil && m.CsharpNamespace != nil {
+		return *m.CsharpNamespace
+	}
+	return ""
+}
+
+func (m *FileOptions) GetSwiftPrefix() string {
+	if m != nil && m.SwiftPrefix != nil {
+		return *m.SwiftPrefix
+	}
+	return ""
+}
+
+func (m *FileOptions) GetPhpClassPrefix() string {
+	if m != nil && m.PhpClassPrefix != nil {
+		return *m.PhpClassPrefix
+	}
+	return ""
+}
+
+func (m *FileOptions) GetPhpNamespace() string {
+	if m != nil && m.PhpNamespace != nil {
+		return *m.PhpNamespace
+	}
+	return ""
+}
+
+func (m *FileOptions) GetPhpMetadataNamespace() string {
+	if m != nil && m.PhpMetadataNamespace != nil {
+		return *m.PhpMetadataNamespace
+	}
+	return ""
+}
+
+func (m *FileOptions) GetRubyPackage() string {
+	if m != nil && m.RubyPackage != nil {
+		return *m.RubyPackage
+	}
+	return ""
+}
+
+func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if m != nil {
+		return m.UninterpretedOption
+	}
+	return nil
+}
+
+type MessageOptions struct {
+	// Set true to use the old proto1 MessageSet wire format for extensions.
+	// This is provided for backwards-compatibility with the MessageSet wire
+	// format.  You should not use this for any other reason:  It's less
+	// efficient, has fewer features, and is more complicated.
+	//
+	// The message must be defined exactly as follows:
+	//   message Foo {
+	//     option message_set_wire_format = true;
+	//     extensions 4 to max;
+	//   }
+	// Note that the message cannot have any defined fields; MessageSets only
+	// have extensions.
+	//
+	// All extensions of your type must be singular messages; e.g. they cannot
+	// be int32s, enums, or repeated messages.
+	//
+	// Because this is an option, the above two restrictions are not enforced by
+	// the protocol compiler.
+	MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"`
+	// Disables the generation of the standard "descriptor()" accessor, which can
+	// conflict with a field of the same name.  This is meant to make migration
+	// from proto1 easier; new code should avoid fields named "descriptor".
+	NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"`
+	// Is this message deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for the message, or it will be completely ignored; in the very least,
+	// this is a formalization for deprecating messages.
+	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// Whether the message is an automatically generated map entry type for the
+	// maps field.
+	//
+	// For maps fields:
+	//     map<KeyType, ValueType> map_field = 1;
+	// The parsed descriptor looks like:
+	//     message MapFieldEntry {
+	//         option map_entry = true;
+	//         optional KeyType key = 1;
+	//         optional ValueType value = 2;
+	//     }
+	//     repeated MapFieldEntry map_field = 1;
+	//
+	// Implementations may choose not to generate the map_entry=true message, but
+	// use a native map in the target language to hold the keys and values.
+	// The reflection APIs in such implementions still need to work as
+	// if the field is a repeated message field.
+	//
+	// NOTE: Do not set the option in .proto files. Always use the maps syntax
+	// instead. The option should only be implicitly set by the proto compiler
+	// parser.
+	MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *MessageOptions) Reset()         { *m = MessageOptions{} }
+func (m *MessageOptions) String() string { return proto.CompactTextString(m) }
+func (*MessageOptions) ProtoMessage()    {}
+func (*MessageOptions) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{11}
+}
+
+var extRange_MessageOptions = []proto.ExtensionRange{
+	{Start: 1000, End: 536870911},
+}
+
+func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_MessageOptions
+}
+
+func (m *MessageOptions) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MessageOptions.Unmarshal(m, b)
+}
+func (m *MessageOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MessageOptions.Marshal(b, m, deterministic)
+}
+func (m *MessageOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MessageOptions.Merge(m, src)
+}
+func (m *MessageOptions) XXX_Size() int {
+	return xxx_messageInfo_MessageOptions.Size(m)
+}
+func (m *MessageOptions) XXX_DiscardUnknown() {
+	xxx_messageInfo_MessageOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MessageOptions proto.InternalMessageInfo
+
+const Default_MessageOptions_MessageSetWireFormat bool = false
+const Default_MessageOptions_NoStandardDescriptorAccessor bool = false
+const Default_MessageOptions_Deprecated bool = false
+
+func (m *MessageOptions) GetMessageSetWireFormat() bool {
+	if m != nil && m.MessageSetWireFormat != nil {
+		return *m.MessageSetWireFormat
+	}
+	return Default_MessageOptions_MessageSetWireFormat
+}
+
+func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool {
+	if m != nil && m.NoStandardDescriptorAccessor != nil {
+		return *m.NoStandardDescriptorAccessor
+	}
+	return Default_MessageOptions_NoStandardDescriptorAccessor
+}
+
+func (m *MessageOptions) GetDeprecated() bool {
+	if m != nil && m.Deprecated != nil {
+		return *m.Deprecated
+	}
+	return Default_MessageOptions_Deprecated
+}
+
+func (m *MessageOptions) GetMapEntry() bool {
+	if m != nil && m.MapEntry != nil {
+		return *m.MapEntry
+	}
+	return false
+}
+
+func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if m != nil {
+		return m.UninterpretedOption
+	}
+	return nil
+}
+
+type FieldOptions struct {
+	// The ctype option instructs the C++ code generator to use a different
+	// representation of the field than it normally would.  See the specific
+	// options below.  This option is not yet implemented in the open source
+	// release -- sorry, we'll try to include it in a future version!
+	Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"`
+	// The packed option can be enabled for repeated primitive fields to enable
+	// a more efficient representation on the wire. Rather than repeatedly
+	// writing the tag and type for each element, the entire array is encoded as
+	// a single length-delimited blob. In proto3, only explicit setting it to
+	// false will avoid using packed encoding.
+	Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
+	// The jstype option determines the JavaScript type used for values of the
+	// field.  The option is permitted only for 64 bit integral and fixed types
+	// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
+	// is represented as JavaScript string, which avoids loss of precision that
+	// can happen when a large value is converted to a floating point JavaScript.
+	// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
+	// use the JavaScript "number" type.  The behavior of the default option
+	// JS_NORMAL is implementation dependent.
+	//
+	// This option is an enum to permit additional types to be added, e.g.
+	// goog.math.Integer.
+	Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
+	// Should this field be parsed lazily?  Lazy applies only to message-type
+	// fields.  It means that when the outer message is initially parsed, the
+	// inner message's contents will not be parsed but instead stored in encoded
+	// form.  The inner message will actually be parsed when it is first accessed.
+	//
+	// This is only a hint.  Implementations are free to choose whether to use
+	// eager or lazy parsing regardless of the value of this option.  However,
+	// setting this option true suggests that the protocol author believes that
+	// using lazy parsing on this field is worth the additional bookkeeping
+	// overhead typically needed to implement it.
+	//
+	// This option does not affect the public interface of any generated code;
+	// all method signatures remain the same.  Furthermore, thread-safety of the
+	// interface is not affected by this option; const methods remain safe to
+	// call from multiple threads concurrently, while non-const methods continue
+	// to require exclusive access.
+	//
+	//
+	// Note that implementations may choose not to check required fields within
+	// a lazy sub-message.  That is, calling IsInitialized() on the outer message
+	// may return true even if the inner message has missing required fields.
+	// This is necessary because otherwise the inner message would have to be
+	// parsed in order to perform the check, defeating the purpose of lazy
+	// parsing.  An implementation which chooses not to check required fields
+	// must be consistent about it.  That is, for any particular sub-message, the
+	// implementation must either *always* check its required fields, or *never*
+	// check its required fields, regardless of whether or not the message has
+	// been parsed.
+	Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"`
+	// Is this field deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for accessors, or it will be completely ignored; in the very least, this
+	// is a formalization for deprecating fields.
+	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// For Google-internal migration only. Do not use.
+	Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *FieldOptions) Reset()         { *m = FieldOptions{} }
+func (m *FieldOptions) String() string { return proto.CompactTextString(m) }
+func (*FieldOptions) ProtoMessage()    {}
+func (*FieldOptions) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{12}
+}
+
+var extRange_FieldOptions = []proto.ExtensionRange{
+	{Start: 1000, End: 536870911},
+}
+
+func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_FieldOptions
+}
+
+func (m *FieldOptions) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FieldOptions.Unmarshal(m, b)
+}
+func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic)
+}
+func (m *FieldOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldOptions.Merge(m, src)
+}
+func (m *FieldOptions) XXX_Size() int {
+	return xxx_messageInfo_FieldOptions.Size(m)
+}
+func (m *FieldOptions) XXX_DiscardUnknown() {
+	xxx_messageInfo_FieldOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldOptions proto.InternalMessageInfo
+
+const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING
+const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL
+const Default_FieldOptions_Lazy bool = false
+const Default_FieldOptions_Deprecated bool = false
+const Default_FieldOptions_Weak bool = false
+
+func (m *FieldOptions) GetCtype() FieldOptions_CType {
+	if m != nil && m.Ctype != nil {
+		return *m.Ctype
+	}
+	return Default_FieldOptions_Ctype
+}
+
+func (m *FieldOptions) GetPacked() bool {
+	if m != nil && m.Packed != nil {
+		return *m.Packed
+	}
+	return false
+}
+
+func (m *FieldOptions) GetJstype() FieldOptions_JSType {
+	if m != nil && m.Jstype != nil {
+		return *m.Jstype
+	}
+	return Default_FieldOptions_Jstype
+}
+
+func (m *FieldOptions) GetLazy() bool {
+	if m != nil && m.Lazy != nil {
+		return *m.Lazy
+	}
+	return Default_FieldOptions_Lazy
+}
+
+func (m *FieldOptions) GetDeprecated() bool {
+	if m != nil && m.Deprecated != nil {
+		return *m.Deprecated
+	}
+	return Default_FieldOptions_Deprecated
+}
+
+func (m *FieldOptions) GetWeak() bool {
+	if m != nil && m.Weak != nil {
+		return *m.Weak
+	}
+	return Default_FieldOptions_Weak
+}
+
+func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if m != nil {
+		return m.UninterpretedOption
+	}
+	return nil
+}
+
+type OneofOptions struct {
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *OneofOptions) Reset()         { *m = OneofOptions{} }
+func (m *OneofOptions) String() string { return proto.CompactTextString(m) }
+func (*OneofOptions) ProtoMessage()    {}
+func (*OneofOptions) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{13}
+}
+
+var extRange_OneofOptions = []proto.ExtensionRange{
+	{Start: 1000, End: 536870911},
+}
+
+func (*OneofOptions) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_OneofOptions
+}
+
+func (m *OneofOptions) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_OneofOptions.Unmarshal(m, b)
+}
+func (m *OneofOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_OneofOptions.Marshal(b, m, deterministic)
+}
+func (m *OneofOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_OneofOptions.Merge(m, src)
+}
+func (m *OneofOptions) XXX_Size() int {
+	return xxx_messageInfo_OneofOptions.Size(m)
+}
+func (m *OneofOptions) XXX_DiscardUnknown() {
+	xxx_messageInfo_OneofOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_OneofOptions proto.InternalMessageInfo
+
+func (m *OneofOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if m != nil {
+		return m.UninterpretedOption
+	}
+	return nil
+}
+
+type EnumOptions struct {
+	// Set this option to true to allow mapping different tag names to the same
+	// value.
+	AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"`
+	// Is this enum deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for the enum, or it will be completely ignored; in the very least, this
+	// is a formalization for deprecating enums.
+	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *EnumOptions) Reset()         { *m = EnumOptions{} }
+func (m *EnumOptions) String() string { return proto.CompactTextString(m) }
+func (*EnumOptions) ProtoMessage()    {}
+func (*EnumOptions) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{14}
+}
+
+var extRange_EnumOptions = []proto.ExtensionRange{
+	{Start: 1000, End: 536870911},
+}
+
+func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_EnumOptions
+}
+
+func (m *EnumOptions) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EnumOptions.Unmarshal(m, b)
+}
+func (m *EnumOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EnumOptions.Marshal(b, m, deterministic)
+}
+func (m *EnumOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EnumOptions.Merge(m, src)
+}
+func (m *EnumOptions) XXX_Size() int {
+	return xxx_messageInfo_EnumOptions.Size(m)
+}
+func (m *EnumOptions) XXX_DiscardUnknown() {
+	xxx_messageInfo_EnumOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumOptions proto.InternalMessageInfo
+
+const Default_EnumOptions_Deprecated bool = false
+
+func (m *EnumOptions) GetAllowAlias() bool {
+	if m != nil && m.AllowAlias != nil {
+		return *m.AllowAlias
+	}
+	return false
+}
+
+func (m *EnumOptions) GetDeprecated() bool {
+	if m != nil && m.Deprecated != nil {
+		return *m.Deprecated
+	}
+	return Default_EnumOptions_Deprecated
+}
+
+func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if m != nil {
+		return m.UninterpretedOption
+	}
+	return nil
+}
+
+type EnumValueOptions struct {
+	// Is this enum value deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for the enum value, or it will be completely ignored; in the very least,
+	// this is a formalization for deprecating enum values.
+	Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *EnumValueOptions) Reset()         { *m = EnumValueOptions{} }
+func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) }
+func (*EnumValueOptions) ProtoMessage()    {}
+func (*EnumValueOptions) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{15}
+}
+
+var extRange_EnumValueOptions = []proto.ExtensionRange{
+	{Start: 1000, End: 536870911},
+}
+
+func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_EnumValueOptions
+}
+
+func (m *EnumValueOptions) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_EnumValueOptions.Unmarshal(m, b)
+}
+func (m *EnumValueOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_EnumValueOptions.Marshal(b, m, deterministic)
+}
+func (m *EnumValueOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EnumValueOptions.Merge(m, src)
+}
+func (m *EnumValueOptions) XXX_Size() int {
+	return xxx_messageInfo_EnumValueOptions.Size(m)
+}
+func (m *EnumValueOptions) XXX_DiscardUnknown() {
+	xxx_messageInfo_EnumValueOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumValueOptions proto.InternalMessageInfo
+
+const Default_EnumValueOptions_Deprecated bool = false
+
+func (m *EnumValueOptions) GetDeprecated() bool {
+	if m != nil && m.Deprecated != nil {
+		return *m.Deprecated
+	}
+	return Default_EnumValueOptions_Deprecated
+}
+
+func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if m != nil {
+		return m.UninterpretedOption
+	}
+	return nil
+}
+
+type ServiceOptions struct {
+	// Is this service deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for the service, or it will be completely ignored; in the very least,
+	// this is a formalization for deprecating services.
+	Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *ServiceOptions) Reset()         { *m = ServiceOptions{} }
+func (m *ServiceOptions) String() string { return proto.CompactTextString(m) }
+func (*ServiceOptions) ProtoMessage()    {}
+func (*ServiceOptions) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{16}
+}
+
+var extRange_ServiceOptions = []proto.ExtensionRange{
+	{Start: 1000, End: 536870911},
+}
+
+func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_ServiceOptions
+}
+
+func (m *ServiceOptions) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ServiceOptions.Unmarshal(m, b)
+}
+func (m *ServiceOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ServiceOptions.Marshal(b, m, deterministic)
+}
+func (m *ServiceOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ServiceOptions.Merge(m, src)
+}
+func (m *ServiceOptions) XXX_Size() int {
+	return xxx_messageInfo_ServiceOptions.Size(m)
+}
+func (m *ServiceOptions) XXX_DiscardUnknown() {
+	xxx_messageInfo_ServiceOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServiceOptions proto.InternalMessageInfo
+
+const Default_ServiceOptions_Deprecated bool = false
+
+func (m *ServiceOptions) GetDeprecated() bool {
+	if m != nil && m.Deprecated != nil {
+		return *m.Deprecated
+	}
+	return Default_ServiceOptions_Deprecated
+}
+
+func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if m != nil {
+		return m.UninterpretedOption
+	}
+	return nil
+}
+
+type MethodOptions struct {
+	// Is this method deprecated?
+	// Depending on the target platform, this can emit Deprecated annotations
+	// for the method, or it will be completely ignored; in the very least,
+	// this is a formalization for deprecating methods.
+	Deprecated       *bool                           `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+	IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"`
+	// The parser stores options it doesn't recognize here. See above.
+	UninterpretedOption          []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{}               `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (m *MethodOptions) Reset()         { *m = MethodOptions{} }
+func (m *MethodOptions) String() string { return proto.CompactTextString(m) }
+func (*MethodOptions) ProtoMessage()    {}
+func (*MethodOptions) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{17}
+}
+
+var extRange_MethodOptions = []proto.ExtensionRange{
+	{Start: 1000, End: 536870911},
+}
+
+func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_MethodOptions
+}
+
+func (m *MethodOptions) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MethodOptions.Unmarshal(m, b)
+}
+func (m *MethodOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MethodOptions.Marshal(b, m, deterministic)
+}
+func (m *MethodOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MethodOptions.Merge(m, src)
+}
+func (m *MethodOptions) XXX_Size() int {
+	return xxx_messageInfo_MethodOptions.Size(m)
+}
+func (m *MethodOptions) XXX_DiscardUnknown() {
+	xxx_messageInfo_MethodOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MethodOptions proto.InternalMessageInfo
+
+const Default_MethodOptions_Deprecated bool = false
+const Default_MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN
+
+func (m *MethodOptions) GetDeprecated() bool {
+	if m != nil && m.Deprecated != nil {
+		return *m.Deprecated
+	}
+	return Default_MethodOptions_Deprecated
+}
+
+func (m *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel {
+	if m != nil && m.IdempotencyLevel != nil {
+		return *m.IdempotencyLevel
+	}
+	return Default_MethodOptions_IdempotencyLevel
+}
+
+func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption {
+	if m != nil {
+		return m.UninterpretedOption
+	}
+	return nil
+}
+
+// A message representing a option the parser does not recognize. This only
+// appears in options protos created by the compiler::Parser class.
+// DescriptorPool resolves these when building Descriptor objects. Therefore,
+// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+// in them.
+type UninterpretedOption struct {
+	Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"`
+	// The value of the uninterpreted option, in whatever type the tokenizer
+	// identified it as during parsing. Exactly one of these should be set.
+	IdentifierValue      *string  `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"`
+	PositiveIntValue     *uint64  `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"`
+	NegativeIntValue     *int64   `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"`
+	DoubleValue          *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
+	StringValue          []byte   `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
+	AggregateValue       *string  `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UninterpretedOption) Reset()         { *m = UninterpretedOption{} }
+func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) }
+func (*UninterpretedOption) ProtoMessage()    {}
+func (*UninterpretedOption) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{18}
+}
+
+func (m *UninterpretedOption) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UninterpretedOption.Unmarshal(m, b)
+}
+func (m *UninterpretedOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UninterpretedOption.Marshal(b, m, deterministic)
+}
+func (m *UninterpretedOption) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UninterpretedOption.Merge(m, src)
+}
+func (m *UninterpretedOption) XXX_Size() int {
+	return xxx_messageInfo_UninterpretedOption.Size(m)
+}
+func (m *UninterpretedOption) XXX_DiscardUnknown() {
+	xxx_messageInfo_UninterpretedOption.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UninterpretedOption proto.InternalMessageInfo
+
+func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
+	if m != nil {
+		return m.Name
+	}
+	return nil
+}
+
+func (m *UninterpretedOption) GetIdentifierValue() string {
+	if m != nil && m.IdentifierValue != nil {
+		return *m.IdentifierValue
+	}
+	return ""
+}
+
+func (m *UninterpretedOption) GetPositiveIntValue() uint64 {
+	if m != nil && m.PositiveIntValue != nil {
+		return *m.PositiveIntValue
+	}
+	return 0
+}
+
+func (m *UninterpretedOption) GetNegativeIntValue() int64 {
+	if m != nil && m.NegativeIntValue != nil {
+		return *m.NegativeIntValue
+	}
+	return 0
+}
+
+func (m *UninterpretedOption) GetDoubleValue() float64 {
+	if m != nil && m.DoubleValue != nil {
+		return *m.DoubleValue
+	}
+	return 0
+}
+
+func (m *UninterpretedOption) GetStringValue() []byte {
+	if m != nil {
+		return m.StringValue
+	}
+	return nil
+}
+
+func (m *UninterpretedOption) GetAggregateValue() string {
+	if m != nil && m.AggregateValue != nil {
+		return *m.AggregateValue
+	}
+	return ""
+}
+
+// The name of the uninterpreted option.  Each string represents a segment in
+// a dot-separated name.  is_extension is true iff a segment represents an
+// extension (denoted with parentheses in options specs in .proto files).
+// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
+// "foo.(bar.baz).qux".
+type UninterpretedOption_NamePart struct {
+	NamePart             *string  `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"`
+	IsExtension          *bool    `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UninterpretedOption_NamePart) Reset()         { *m = UninterpretedOption_NamePart{} }
+func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) }
+func (*UninterpretedOption_NamePart) ProtoMessage()    {}
+func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{18, 0}
+}
+
+func (m *UninterpretedOption_NamePart) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UninterpretedOption_NamePart.Unmarshal(m, b)
+}
+func (m *UninterpretedOption_NamePart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UninterpretedOption_NamePart.Marshal(b, m, deterministic)
+}
+func (m *UninterpretedOption_NamePart) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UninterpretedOption_NamePart.Merge(m, src)
+}
+func (m *UninterpretedOption_NamePart) XXX_Size() int {
+	return xxx_messageInfo_UninterpretedOption_NamePart.Size(m)
+}
+func (m *UninterpretedOption_NamePart) XXX_DiscardUnknown() {
+	xxx_messageInfo_UninterpretedOption_NamePart.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UninterpretedOption_NamePart proto.InternalMessageInfo
+
+func (m *UninterpretedOption_NamePart) GetNamePart() string {
+	if m != nil && m.NamePart != nil {
+		return *m.NamePart
+	}
+	return ""
+}
+
+func (m *UninterpretedOption_NamePart) GetIsExtension() bool {
+	if m != nil && m.IsExtension != nil {
+		return *m.IsExtension
+	}
+	return false
+}
+
+// Encapsulates information about the original source file from which a
+// FileDescriptorProto was generated.
+type SourceCodeInfo struct {
+	// A Location identifies a piece of source code in a .proto file which
+	// corresponds to a particular definition.  This information is intended
+	// to be useful to IDEs, code indexers, documentation generators, and similar
+	// tools.
+	//
+	// For example, say we have a file like:
+	//   message Foo {
+	//     optional string foo = 1;
+	//   }
+	// Let's look at just the field definition:
+	//   optional string foo = 1;
+	//   ^       ^^     ^^  ^  ^^^
+	//   a       bc     de  f  ghi
+	// We have the following locations:
+	//   span   path               represents
+	//   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
+	//   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
+	//   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
+	//   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
+	//   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
+	//
+	// Notes:
+	// - A location may refer to a repeated field itself (i.e. not to any
+	//   particular index within it).  This is used whenever a set of elements are
+	//   logically enclosed in a single code segment.  For example, an entire
+	//   extend block (possibly containing multiple extension definitions) will
+	//   have an outer location whose path refers to the "extensions" repeated
+	//   field without an index.
+	// - Multiple locations may have the same path.  This happens when a single
+	//   logical declaration is spread out across multiple places.  The most
+	//   obvious example is the "extend" block again -- there may be multiple
+	//   extend blocks in the same scope, each of which will have the same path.
+	// - A location's span is not always a subset of its parent's span.  For
+	//   example, the "extendee" of an extension declaration appears at the
+	//   beginning of the "extend" block and is shared by all extensions within
+	//   the block.
+	// - Just because a location's span is a subset of some other location's span
+	//   does not mean that it is a descendent.  For example, a "group" defines
+	//   both a type and a field in a single declaration.  Thus, the locations
+	//   corresponding to the type and field and their components will overlap.
+	// - Code which tries to interpret locations should probably be designed to
+	//   ignore those that it doesn't understand, as more types of locations could
+	//   be recorded in the future.
+	Location             []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
+	XXX_unrecognized     []byte                     `json:"-"`
+	XXX_sizecache        int32                      `json:"-"`
+}
+
+func (m *SourceCodeInfo) Reset()         { *m = SourceCodeInfo{} }
+func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) }
+func (*SourceCodeInfo) ProtoMessage()    {}
+func (*SourceCodeInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{19}
+}
+
+func (m *SourceCodeInfo) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SourceCodeInfo.Unmarshal(m, b)
+}
+func (m *SourceCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SourceCodeInfo.Marshal(b, m, deterministic)
+}
+func (m *SourceCodeInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SourceCodeInfo.Merge(m, src)
+}
+func (m *SourceCodeInfo) XXX_Size() int {
+	return xxx_messageInfo_SourceCodeInfo.Size(m)
+}
+func (m *SourceCodeInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_SourceCodeInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SourceCodeInfo proto.InternalMessageInfo
+
+func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
+	if m != nil {
+		return m.Location
+	}
+	return nil
+}
+
+type SourceCodeInfo_Location struct {
+	// Identifies which part of the FileDescriptorProto was defined at this
+	// location.
+	//
+	// Each element is a field number or an index.  They form a path from
+	// the root FileDescriptorProto to the place where the definition.  For
+	// example, this path:
+	//   [ 4, 3, 2, 7, 1 ]
+	// refers to:
+	//   file.message_type(3)  // 4, 3
+	//       .field(7)         // 2, 7
+	//       .name()           // 1
+	// This is because FileDescriptorProto.message_type has field number 4:
+	//   repeated DescriptorProto message_type = 4;
+	// and DescriptorProto.field has field number 2:
+	//   repeated FieldDescriptorProto field = 2;
+	// and FieldDescriptorProto.name has field number 1:
+	//   optional string name = 1;
+	//
+	// Thus, the above path gives the location of a field name.  If we removed
+	// the last element:
+	//   [ 4, 3, 2, 7 ]
+	// this path refers to the whole field declaration (from the beginning
+	// of the label to the terminating semicolon).
+	Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
+	// Always has exactly three or four elements: start line, start column,
+	// end line (optional, otherwise assumed same as start line), end column.
+	// These are packed into a single field for efficiency.  Note that line
+	// and column numbers are zero-based -- typically you will want to add
+	// 1 to each before displaying to a user.
+	Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"`
+	// If this SourceCodeInfo represents a complete declaration, these are any
+	// comments appearing before and after the declaration which appear to be
+	// attached to the declaration.
+	//
+	// A series of line comments appearing on consecutive lines, with no other
+	// tokens appearing on those lines, will be treated as a single comment.
+	//
+	// leading_detached_comments will keep paragraphs of comments that appear
+	// before (but not connected to) the current element. Each paragraph,
+	// separated by empty lines, will be one comment element in the repeated
+	// field.
+	//
+	// Only the comment content is provided; comment markers (e.g. //) are
+	// stripped out.  For block comments, leading whitespace and an asterisk
+	// will be stripped from the beginning of each line other than the first.
+	// Newlines are included in the output.
+	//
+	// Examples:
+	//
+	//   optional int32 foo = 1;  // Comment attached to foo.
+	//   // Comment attached to bar.
+	//   optional int32 bar = 2;
+	//
+	//   optional string baz = 3;
+	//   // Comment attached to baz.
+	//   // Another line attached to baz.
+	//
+	//   // Comment attached to qux.
+	//   //
+	//   // Another line attached to qux.
+	//   optional double qux = 4;
+	//
+	//   // Detached comment for corge. This is not leading or trailing comments
+	//   // to qux or corge because there are blank lines separating it from
+	//   // both.
+	//
+	//   // Detached comment for corge paragraph 2.
+	//
+	//   optional string corge = 5;
+	//   /* Block comment attached
+	//    * to corge.  Leading asterisks
+	//    * will be removed. */
+	//   /* Block comment attached to
+	//    * grault. */
+	//   optional int32 grault = 6;
+	//
+	//   // ignored detached comments.
+	LeadingComments         *string  `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"`
+	TrailingComments        *string  `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"`
+	LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"`
+	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
+	XXX_unrecognized        []byte   `json:"-"`
+	XXX_sizecache           int32    `json:"-"`
+}
+
+func (m *SourceCodeInfo_Location) Reset()         { *m = SourceCodeInfo_Location{} }
+func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) }
+func (*SourceCodeInfo_Location) ProtoMessage()    {}
+func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{19, 0}
+}
+
+func (m *SourceCodeInfo_Location) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SourceCodeInfo_Location.Unmarshal(m, b)
+}
+func (m *SourceCodeInfo_Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SourceCodeInfo_Location.Marshal(b, m, deterministic)
+}
+func (m *SourceCodeInfo_Location) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SourceCodeInfo_Location.Merge(m, src)
+}
+func (m *SourceCodeInfo_Location) XXX_Size() int {
+	return xxx_messageInfo_SourceCodeInfo_Location.Size(m)
+}
+func (m *SourceCodeInfo_Location) XXX_DiscardUnknown() {
+	xxx_messageInfo_SourceCodeInfo_Location.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SourceCodeInfo_Location proto.InternalMessageInfo
+
+func (m *SourceCodeInfo_Location) GetPath() []int32 {
+	if m != nil {
+		return m.Path
+	}
+	return nil
+}
+
+func (m *SourceCodeInfo_Location) GetSpan() []int32 {
+	if m != nil {
+		return m.Span
+	}
+	return nil
+}
+
+func (m *SourceCodeInfo_Location) GetLeadingComments() string {
+	if m != nil && m.LeadingComments != nil {
+		return *m.LeadingComments
+	}
+	return ""
+}
+
+func (m *SourceCodeInfo_Location) GetTrailingComments() string {
+	if m != nil && m.TrailingComments != nil {
+		return *m.TrailingComments
+	}
+	return ""
+}
+
+func (m *SourceCodeInfo_Location) GetLeadingDetachedComments() []string {
+	if m != nil {
+		return m.LeadingDetachedComments
+	}
+	return nil
+}
+
+// Describes the relationship between generated code and its original source
+// file. A GeneratedCodeInfo message is associated with only one generated
+// source file, but may contain references to different source .proto files.
+type GeneratedCodeInfo struct {
+	// An Annotation connects some span of text in generated code to an element
+	// of its generating .proto file.
+	Annotation           []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
+	XXX_unrecognized     []byte                          `json:"-"`
+	XXX_sizecache        int32                           `json:"-"`
+}
+
+func (m *GeneratedCodeInfo) Reset()         { *m = GeneratedCodeInfo{} }
+func (m *GeneratedCodeInfo) String() string { return proto.CompactTextString(m) }
+func (*GeneratedCodeInfo) ProtoMessage()    {}
+func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{20}
+}
+
+func (m *GeneratedCodeInfo) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GeneratedCodeInfo.Unmarshal(m, b)
+}
+func (m *GeneratedCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GeneratedCodeInfo.Marshal(b, m, deterministic)
+}
+func (m *GeneratedCodeInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GeneratedCodeInfo.Merge(m, src)
+}
+func (m *GeneratedCodeInfo) XXX_Size() int {
+	return xxx_messageInfo_GeneratedCodeInfo.Size(m)
+}
+func (m *GeneratedCodeInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_GeneratedCodeInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GeneratedCodeInfo proto.InternalMessageInfo
+
+func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
+	if m != nil {
+		return m.Annotation
+	}
+	return nil
+}
+
+type GeneratedCodeInfo_Annotation struct {
+	// Identifies the element in the original source .proto file. This field
+	// is formatted the same as SourceCodeInfo.Location.path.
+	Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
+	// Identifies the filesystem path to the original source .proto.
+	SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
+	// Identifies the starting offset in bytes in the generated code
+	// that relates to the identified object.
+	Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"`
+	// Identifies the ending offset in bytes in the generated code that
+	// relates to the identified offset. The end offset should be one past
+	// the last relevant byte (so the length of the text = end - begin).
+	End                  *int32   `protobuf:"varint,4,opt,name=end" json:"end,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GeneratedCodeInfo_Annotation) Reset()         { *m = GeneratedCodeInfo_Annotation{} }
+func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) }
+func (*GeneratedCodeInfo_Annotation) ProtoMessage()    {}
+func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e5baabe45344a177, []int{20, 0}
+}
+
+func (m *GeneratedCodeInfo_Annotation) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GeneratedCodeInfo_Annotation.Unmarshal(m, b)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GeneratedCodeInfo_Annotation.Marshal(b, m, deterministic)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GeneratedCodeInfo_Annotation.Merge(m, src)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_Size() int {
+	return xxx_messageInfo_GeneratedCodeInfo_Annotation.Size(m)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_DiscardUnknown() {
+	xxx_messageInfo_GeneratedCodeInfo_Annotation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GeneratedCodeInfo_Annotation proto.InternalMessageInfo
+
+func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 {
+	if m != nil {
+		return m.Path
+	}
+	return nil
+}
+
+func (m *GeneratedCodeInfo_Annotation) GetSourceFile() string {
+	if m != nil && m.SourceFile != nil {
+		return *m.SourceFile
+	}
+	return ""
+}
+
+func (m *GeneratedCodeInfo_Annotation) GetBegin() int32 {
+	if m != nil && m.Begin != nil {
+		return *m.Begin
+	}
+	return 0
+}
+
+func (m *GeneratedCodeInfo_Annotation) GetEnd() int32 {
+	if m != nil && m.End != nil {
+		return *m.End
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value)
+	proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value)
+	proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value)
+	proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value)
+	proto.RegisterEnum("google.protobuf.FieldOptions_JSType", FieldOptions_JSType_name, FieldOptions_JSType_value)
+	proto.RegisterEnum("google.protobuf.MethodOptions_IdempotencyLevel", MethodOptions_IdempotencyLevel_name, MethodOptions_IdempotencyLevel_value)
+	proto.RegisterType((*FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet")
+	proto.RegisterType((*FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto")
+	proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto")
+	proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange")
+	proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange")
+	proto.RegisterType((*ExtensionRangeOptions)(nil), "google.protobuf.ExtensionRangeOptions")
+	proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto")
+	proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto")
+	proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto")
+	proto.RegisterType((*EnumDescriptorProto_EnumReservedRange)(nil), "google.protobuf.EnumDescriptorProto.EnumReservedRange")
+	proto.RegisterType((*EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto")
+	proto.RegisterType((*ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto")
+	proto.RegisterType((*MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto")
+	proto.RegisterType((*FileOptions)(nil), "google.protobuf.FileOptions")
+	proto.RegisterType((*MessageOptions)(nil), "google.protobuf.MessageOptions")
+	proto.RegisterType((*FieldOptions)(nil), "google.protobuf.FieldOptions")
+	proto.RegisterType((*OneofOptions)(nil), "google.protobuf.OneofOptions")
+	proto.RegisterType((*EnumOptions)(nil), "google.protobuf.EnumOptions")
+	proto.RegisterType((*EnumValueOptions)(nil), "google.protobuf.EnumValueOptions")
+	proto.RegisterType((*ServiceOptions)(nil), "google.protobuf.ServiceOptions")
+	proto.RegisterType((*MethodOptions)(nil), "google.protobuf.MethodOptions")
+	proto.RegisterType((*UninterpretedOption)(nil), "google.protobuf.UninterpretedOption")
+	proto.RegisterType((*UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart")
+	proto.RegisterType((*SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo")
+	proto.RegisterType((*SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location")
+	proto.RegisterType((*GeneratedCodeInfo)(nil), "google.protobuf.GeneratedCodeInfo")
+	proto.RegisterType((*GeneratedCodeInfo_Annotation)(nil), "google.protobuf.GeneratedCodeInfo.Annotation")
+}
+
+func init() { proto.RegisterFile("google/protobuf/descriptor.proto", fileDescriptor_e5baabe45344a177) }
+
+var fileDescriptor_e5baabe45344a177 = []byte{
+	// 2589 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xdd, 0x8e, 0xdb, 0xc6,
+	0x15, 0x0e, 0xf5, 0xb7, 0xd2, 0x91, 0x56, 0x3b, 0x3b, 0xbb, 0xb1, 0xe9, 0xcd, 0x8f, 0xd7, 0xca,
+	0x8f, 0xd7, 0x4e, 0xac, 0x0d, 0x1c, 0xdb, 0x71, 0xd6, 0x45, 0x5a, 0xad, 0x44, 0x6f, 0xe4, 0xee,
+	0x4a, 0x2a, 0xa5, 0x6d, 0x7e, 0x80, 0x82, 0x98, 0x25, 0x47, 0x12, 0x6d, 0x8a, 0x64, 0x48, 0xca,
+	0xf6, 0x06, 0xbd, 0x30, 0xd0, 0xab, 0x5e, 0x15, 0xe8, 0x55, 0x51, 0x14, 0xbd, 0xe8, 0x4d, 0x80,
+	0x3e, 0x40, 0x81, 0xde, 0xf5, 0x09, 0x0a, 0xe4, 0x0d, 0x8a, 0xb6, 0x40, 0xfb, 0x08, 0xbd, 0x2c,
+	0x66, 0x86, 0xa4, 0x48, 0x49, 0x1b, 0x6f, 0x02, 0xc4, 0xb9, 0x92, 0xe6, 0x3b, 0xdf, 0x39, 0x73,
+	0xe6, 0xcc, 0x99, 0x99, 0x33, 0x43, 0xd8, 0x1e, 0x39, 0xce, 0xc8, 0xa2, 0xbb, 0xae, 0xe7, 0x04,
+	0xce, 0xc9, 0x74, 0xb8, 0x6b, 0x50, 0x5f, 0xf7, 0x4c, 0x37, 0x70, 0xbc, 0x3a, 0xc7, 0xf0, 0x9a,
+	0x60, 0xd4, 0x23, 0x46, 0xed, 0x08, 0xd6, 0xef, 0x9b, 0x16, 0x6d, 0xc5, 0xc4, 0x3e, 0x0d, 0xf0,
+	0x5d, 0xc8, 0x0d, 0x4d, 0x8b, 0xca, 0xd2, 0x76, 0x76, 0xa7, 0x7c, 0xf3, 0xcd, 0xfa, 0x9c, 0x52,
+	0x3d, 0xad, 0xd1, 0x63, 0xb0, 0xca, 0x35, 0x6a, 0xff, 0xce, 0xc1, 0xc6, 0x12, 0x29, 0xc6, 0x90,
+	0xb3, 0xc9, 0x84, 0x59, 0x94, 0x76, 0x4a, 0x2a, 0xff, 0x8f, 0x65, 0x58, 0x71, 0x89, 0xfe, 0x88,
+	0x8c, 0xa8, 0x9c, 0xe1, 0x70, 0xd4, 0xc4, 0xaf, 0x03, 0x18, 0xd4, 0xa5, 0xb6, 0x41, 0x6d, 0xfd,
+	0x54, 0xce, 0x6e, 0x67, 0x77, 0x4a, 0x6a, 0x02, 0xc1, 0xef, 0xc0, 0xba, 0x3b, 0x3d, 0xb1, 0x4c,
+	0x5d, 0x4b, 0xd0, 0x60, 0x3b, 0xbb, 0x93, 0x57, 0x91, 0x10, 0xb4, 0x66, 0xe4, 0xab, 0xb0, 0xf6,
+	0x84, 0x92, 0x47, 0x49, 0x6a, 0x99, 0x53, 0xab, 0x0c, 0x4e, 0x10, 0x9b, 0x50, 0x99, 0x50, 0xdf,
+	0x27, 0x23, 0xaa, 0x05, 0xa7, 0x2e, 0x95, 0x73, 0x7c, 0xf4, 0xdb, 0x0b, 0xa3, 0x9f, 0x1f, 0x79,
+	0x39, 0xd4, 0x1a, 0x9c, 0xba, 0x14, 0x37, 0xa0, 0x44, 0xed, 0xe9, 0x44, 0x58, 0xc8, 0x9f, 0x11,
+	0x3f, 0xc5, 0x9e, 0x4e, 0xe6, 0xad, 0x14, 0x99, 0x5a, 0x68, 0x62, 0xc5, 0xa7, 0xde, 0x63, 0x53,
+	0xa7, 0x72, 0x81, 0x1b, 0xb8, 0xba, 0x60, 0xa0, 0x2f, 0xe4, 0xf3, 0x36, 0x22, 0x3d, 0xdc, 0x84,
+	0x12, 0x7d, 0x1a, 0x50, 0xdb, 0x37, 0x1d, 0x5b, 0x5e, 0xe1, 0x46, 0xde, 0x5a, 0x32, 0x8b, 0xd4,
+	0x32, 0xe6, 0x4d, 0xcc, 0xf4, 0xf0, 0x1d, 0x58, 0x71, 0xdc, 0xc0, 0x74, 0x6c, 0x5f, 0x2e, 0x6e,
+	0x4b, 0x3b, 0xe5, 0x9b, 0xaf, 0x2e, 0x4d, 0x84, 0xae, 0xe0, 0xa8, 0x11, 0x19, 0xb7, 0x01, 0xf9,
+	0xce, 0xd4, 0xd3, 0xa9, 0xa6, 0x3b, 0x06, 0xd5, 0x4c, 0x7b, 0xe8, 0xc8, 0x25, 0x6e, 0xe0, 0xf2,
+	0xe2, 0x40, 0x38, 0xb1, 0xe9, 0x18, 0xb4, 0x6d, 0x0f, 0x1d, 0xb5, 0xea, 0xa7, 0xda, 0xf8, 0x02,
+	0x14, 0xfc, 0x53, 0x3b, 0x20, 0x4f, 0xe5, 0x0a, 0xcf, 0x90, 0xb0, 0x55, 0xfb, 0x6b, 0x01, 0xd6,
+	0xce, 0x93, 0x62, 0xf7, 0x20, 0x3f, 0x64, 0xa3, 0x94, 0x33, 0xdf, 0x26, 0x06, 0x42, 0x27, 0x1d,
+	0xc4, 0xc2, 0x77, 0x0c, 0x62, 0x03, 0xca, 0x36, 0xf5, 0x03, 0x6a, 0x88, 0x8c, 0xc8, 0x9e, 0x33,
+	0xa7, 0x40, 0x28, 0x2d, 0xa6, 0x54, 0xee, 0x3b, 0xa5, 0xd4, 0xa7, 0xb0, 0x16, 0xbb, 0xa4, 0x79,
+	0xc4, 0x1e, 0x45, 0xb9, 0xb9, 0xfb, 0x3c, 0x4f, 0xea, 0x4a, 0xa4, 0xa7, 0x32, 0x35, 0xb5, 0x4a,
+	0x53, 0x6d, 0xdc, 0x02, 0x70, 0x6c, 0xea, 0x0c, 0x35, 0x83, 0xea, 0x96, 0x5c, 0x3c, 0x23, 0x4a,
+	0x5d, 0x46, 0x59, 0x88, 0x92, 0x23, 0x50, 0xdd, 0xc2, 0x1f, 0xce, 0x52, 0x6d, 0xe5, 0x8c, 0x4c,
+	0x39, 0x12, 0x8b, 0x6c, 0x21, 0xdb, 0x8e, 0xa1, 0xea, 0x51, 0x96, 0xf7, 0xd4, 0x08, 0x47, 0x56,
+	0xe2, 0x4e, 0xd4, 0x9f, 0x3b, 0x32, 0x35, 0x54, 0x13, 0x03, 0x5b, 0xf5, 0x92, 0x4d, 0xfc, 0x06,
+	0xc4, 0x80, 0xc6, 0xd3, 0x0a, 0xf8, 0x2e, 0x54, 0x89, 0xc0, 0x0e, 0x99, 0xd0, 0xad, 0x2f, 0xa1,
+	0x9a, 0x0e, 0x0f, 0xde, 0x84, 0xbc, 0x1f, 0x10, 0x2f, 0xe0, 0x59, 0x98, 0x57, 0x45, 0x03, 0x23,
+	0xc8, 0x52, 0xdb, 0xe0, 0xbb, 0x5c, 0x5e, 0x65, 0x7f, 0xf1, 0x4f, 0x66, 0x03, 0xce, 0xf2, 0x01,
+	0xbf, 0xbd, 0x38, 0xa3, 0x29, 0xcb, 0xf3, 0xe3, 0xde, 0xfa, 0x00, 0x56, 0x53, 0x03, 0x38, 0x6f,
+	0xd7, 0xb5, 0x5f, 0xc2, 0xcb, 0x4b, 0x4d, 0xe3, 0x4f, 0x61, 0x73, 0x6a, 0x9b, 0x76, 0x40, 0x3d,
+	0xd7, 0xa3, 0x2c, 0x63, 0x45, 0x57, 0xf2, 0x7f, 0x56, 0xce, 0xc8, 0xb9, 0xe3, 0x24, 0x5b, 0x58,
+	0x51, 0x37, 0xa6, 0x8b, 0xe0, 0xf5, 0x52, 0xf1, 0xbf, 0x2b, 0xe8, 0xd9, 0xb3, 0x67, 0xcf, 0x32,
+	0xb5, 0xdf, 0x15, 0x60, 0x73, 0xd9, 0x9a, 0x59, 0xba, 0x7c, 0x2f, 0x40, 0xc1, 0x9e, 0x4e, 0x4e,
+	0xa8, 0xc7, 0x83, 0x94, 0x57, 0xc3, 0x16, 0x6e, 0x40, 0xde, 0x22, 0x27, 0xd4, 0x92, 0x73, 0xdb,
+	0xd2, 0x4e, 0xf5, 0xe6, 0x3b, 0xe7, 0x5a, 0x95, 0xf5, 0x43, 0xa6, 0xa2, 0x0a, 0x4d, 0xfc, 0x11,
+	0xe4, 0xc2, 0x2d, 0x9a, 0x59, 0xb8, 0x7e, 0x3e, 0x0b, 0x6c, 0x2d, 0xa9, 0x5c, 0x0f, 0xbf, 0x02,
+	0x25, 0xf6, 0x2b, 0x72, 0xa3, 0xc0, 0x7d, 0x2e, 0x32, 0x80, 0xe5, 0x05, 0xde, 0x82, 0x22, 0x5f,
+	0x26, 0x06, 0x8d, 0x8e, 0xb6, 0xb8, 0xcd, 0x12, 0xcb, 0xa0, 0x43, 0x32, 0xb5, 0x02, 0xed, 0x31,
+	0xb1, 0xa6, 0x94, 0x27, 0x7c, 0x49, 0xad, 0x84, 0xe0, 0xcf, 0x19, 0x86, 0x2f, 0x43, 0x59, 0xac,
+	0x2a, 0xd3, 0x36, 0xe8, 0x53, 0xbe, 0x7b, 0xe6, 0x55, 0xb1, 0xd0, 0xda, 0x0c, 0x61, 0xdd, 0x3f,
+	0xf4, 0x1d, 0x3b, 0x4a, 0x4d, 0xde, 0x05, 0x03, 0x78, 0xf7, 0x1f, 0xcc, 0x6f, 0xdc, 0xaf, 0x2d,
+	0x1f, 0xde, 0x7c, 0x4e, 0xd5, 0xfe, 0x92, 0x81, 0x1c, 0xdf, 0x2f, 0xd6, 0xa0, 0x3c, 0xf8, 0xac,
+	0xa7, 0x68, 0xad, 0xee, 0xf1, 0xfe, 0xa1, 0x82, 0x24, 0x5c, 0x05, 0xe0, 0xc0, 0xfd, 0xc3, 0x6e,
+	0x63, 0x80, 0x32, 0x71, 0xbb, 0xdd, 0x19, 0xdc, 0xb9, 0x85, 0xb2, 0xb1, 0xc2, 0xb1, 0x00, 0x72,
+	0x49, 0xc2, 0xfb, 0x37, 0x51, 0x1e, 0x23, 0xa8, 0x08, 0x03, 0xed, 0x4f, 0x95, 0xd6, 0x9d, 0x5b,
+	0xa8, 0x90, 0x46, 0xde, 0xbf, 0x89, 0x56, 0xf0, 0x2a, 0x94, 0x38, 0xb2, 0xdf, 0xed, 0x1e, 0xa2,
+	0x62, 0x6c, 0xb3, 0x3f, 0x50, 0xdb, 0x9d, 0x03, 0x54, 0x8a, 0x6d, 0x1e, 0xa8, 0xdd, 0xe3, 0x1e,
+	0x82, 0xd8, 0xc2, 0x91, 0xd2, 0xef, 0x37, 0x0e, 0x14, 0x54, 0x8e, 0x19, 0xfb, 0x9f, 0x0d, 0x94,
+	0x3e, 0xaa, 0xa4, 0xdc, 0x7a, 0xff, 0x26, 0x5a, 0x8d, 0xbb, 0x50, 0x3a, 0xc7, 0x47, 0xa8, 0x8a,
+	0xd7, 0x61, 0x55, 0x74, 0x11, 0x39, 0xb1, 0x36, 0x07, 0xdd, 0xb9, 0x85, 0xd0, 0xcc, 0x11, 0x61,
+	0x65, 0x3d, 0x05, 0xdc, 0xb9, 0x85, 0x70, 0xad, 0x09, 0x79, 0x9e, 0x5d, 0x18, 0x43, 0xf5, 0xb0,
+	0xb1, 0xaf, 0x1c, 0x6a, 0xdd, 0xde, 0xa0, 0xdd, 0xed, 0x34, 0x0e, 0x91, 0x34, 0xc3, 0x54, 0xe5,
+	0x67, 0xc7, 0x6d, 0x55, 0x69, 0xa1, 0x4c, 0x12, 0xeb, 0x29, 0x8d, 0x81, 0xd2, 0x42, 0xd9, 0x9a,
+	0x0e, 0x9b, 0xcb, 0xf6, 0xc9, 0xa5, 0x2b, 0x23, 0x31, 0xc5, 0x99, 0x33, 0xa6, 0x98, 0xdb, 0x5a,
+	0x98, 0xe2, 0x7f, 0x65, 0x60, 0x63, 0xc9, 0x59, 0xb1, 0xb4, 0x93, 0x1f, 0x43, 0x5e, 0xa4, 0xa8,
+	0x38, 0x3d, 0xaf, 0x2d, 0x3d, 0x74, 0x78, 0xc2, 0x2e, 0x9c, 0xa0, 0x5c, 0x2f, 0x59, 0x41, 0x64,
+	0xcf, 0xa8, 0x20, 0x98, 0x89, 0x85, 0x3d, 0xfd, 0x17, 0x0b, 0x7b, 0xba, 0x38, 0xf6, 0xee, 0x9c,
+	0xe7, 0xd8, 0xe3, 0xd8, 0xb7, 0xdb, 0xdb, 0xf3, 0x4b, 0xf6, 0xf6, 0x7b, 0xb0, 0xbe, 0x60, 0xe8,
+	0xdc, 0x7b, 0xec, 0xaf, 0x24, 0x90, 0xcf, 0x0a, 0xce, 0x73, 0x76, 0xba, 0x4c, 0x6a, 0xa7, 0xbb,
+	0x37, 0x1f, 0xc1, 0x2b, 0x67, 0x4f, 0xc2, 0xc2, 0x5c, 0x7f, 0x25, 0xc1, 0x85, 0xe5, 0x95, 0xe2,
+	0x52, 0x1f, 0x3e, 0x82, 0xc2, 0x84, 0x06, 0x63, 0x27, 0xaa, 0x96, 0xde, 0x5e, 0x72, 0x06, 0x33,
+	0xf1, 0xfc, 0x64, 0x87, 0x5a, 0xc9, 0x43, 0x3c, 0x7b, 0x56, 0xb9, 0x27, 0xbc, 0x59, 0xf0, 0xf4,
+	0xd7, 0x19, 0x78, 0x79, 0xa9, 0xf1, 0xa5, 0x8e, 0xbe, 0x06, 0x60, 0xda, 0xee, 0x34, 0x10, 0x15,
+	0x91, 0xd8, 0x60, 0x4b, 0x1c, 0xe1, 0x9b, 0x17, 0xdb, 0x3c, 0xa7, 0x41, 0x2c, 0xcf, 0x72, 0x39,
+	0x08, 0x88, 0x13, 0xee, 0xce, 0x1c, 0xcd, 0x71, 0x47, 0x5f, 0x3f, 0x63, 0xa4, 0x0b, 0x89, 0xf9,
+	0x1e, 0x20, 0xdd, 0x32, 0xa9, 0x1d, 0x68, 0x7e, 0xe0, 0x51, 0x32, 0x31, 0xed, 0x11, 0x3f, 0x41,
+	0x8a, 0x7b, 0xf9, 0x21, 0xb1, 0x7c, 0xaa, 0xae, 0x09, 0x71, 0x3f, 0x92, 0x32, 0x0d, 0x9e, 0x40,
+	0x5e, 0x42, 0xa3, 0x90, 0xd2, 0x10, 0xe2, 0x58, 0xa3, 0xf6, 0xdb, 0x12, 0x94, 0x13, 0x75, 0x35,
+	0xbe, 0x02, 0x95, 0x87, 0xe4, 0x31, 0xd1, 0xa2, 0xbb, 0x92, 0x88, 0x44, 0x99, 0x61, 0xbd, 0xf0,
+	0xbe, 0xf4, 0x1e, 0x6c, 0x72, 0x8a, 0x33, 0x0d, 0xa8, 0xa7, 0xe9, 0x16, 0xf1, 0x7d, 0x1e, 0xb4,
+	0x22, 0xa7, 0x62, 0x26, 0xeb, 0x32, 0x51, 0x33, 0x92, 0xe0, 0xdb, 0xb0, 0xc1, 0x35, 0x26, 0x53,
+	0x2b, 0x30, 0x5d, 0x8b, 0x6a, 0xec, 0xf6, 0xe6, 0xf3, 0x93, 0x24, 0xf6, 0x6c, 0x9d, 0x31, 0x8e,
+	0x42, 0x02, 0xf3, 0xc8, 0xc7, 0x2d, 0x78, 0x8d, 0xab, 0x8d, 0xa8, 0x4d, 0x3d, 0x12, 0x50, 0x8d,
+	0x7e, 0x31, 0x25, 0x96, 0xaf, 0x11, 0xdb, 0xd0, 0xc6, 0xc4, 0x1f, 0xcb, 0x9b, 0xcc, 0xc0, 0x7e,
+	0x46, 0x96, 0xd4, 0x4b, 0x8c, 0x78, 0x10, 0xf2, 0x14, 0x4e, 0x6b, 0xd8, 0xc6, 0xc7, 0xc4, 0x1f,
+	0xe3, 0x3d, 0xb8, 0xc0, 0xad, 0xf8, 0x81, 0x67, 0xda, 0x23, 0x4d, 0x1f, 0x53, 0xfd, 0x91, 0x36,
+	0x0d, 0x86, 0x77, 0xe5, 0x57, 0x92, 0xfd, 0x73, 0x0f, 0xfb, 0x9c, 0xd3, 0x64, 0x94, 0xe3, 0x60,
+	0x78, 0x17, 0xf7, 0xa1, 0xc2, 0x26, 0x63, 0x62, 0x7e, 0x49, 0xb5, 0xa1, 0xe3, 0xf1, 0xa3, 0xb1,
+	0xba, 0x64, 0x6b, 0x4a, 0x44, 0xb0, 0xde, 0x0d, 0x15, 0x8e, 0x1c, 0x83, 0xee, 0xe5, 0xfb, 0x3d,
+	0x45, 0x69, 0xa9, 0xe5, 0xc8, 0xca, 0x7d, 0xc7, 0x63, 0x09, 0x35, 0x72, 0xe2, 0x00, 0x97, 0x45,
+	0x42, 0x8d, 0x9c, 0x28, 0xbc, 0xb7, 0x61, 0x43, 0xd7, 0xc5, 0x98, 0x4d, 0x5d, 0x0b, 0xef, 0x58,
+	0xbe, 0x8c, 0x52, 0xc1, 0xd2, 0xf5, 0x03, 0x41, 0x08, 0x73, 0xdc, 0xc7, 0x1f, 0xc2, 0xcb, 0xb3,
+	0x60, 0x25, 0x15, 0xd7, 0x17, 0x46, 0x39, 0xaf, 0x7a, 0x1b, 0x36, 0xdc, 0xd3, 0x45, 0x45, 0x9c,
+	0xea, 0xd1, 0x3d, 0x9d, 0x57, 0xfb, 0x00, 0x36, 0xdd, 0xb1, 0xbb, 0xa8, 0x77, 0x3d, 0xa9, 0x87,
+	0xdd, 0xb1, 0x3b, 0xaf, 0xf8, 0x16, 0xbf, 0x70, 0x7b, 0x54, 0x27, 0x01, 0x35, 0xe4, 0x8b, 0x49,
+	0x7a, 0x42, 0x80, 0x77, 0x01, 0xe9, 0xba, 0x46, 0x6d, 0x72, 0x62, 0x51, 0x8d, 0x78, 0xd4, 0x26,
+	0xbe, 0x7c, 0x39, 0x49, 0xae, 0xea, 0xba, 0xc2, 0xa5, 0x0d, 0x2e, 0xc4, 0xd7, 0x61, 0xdd, 0x39,
+	0x79, 0xa8, 0x8b, 0x94, 0xd4, 0x5c, 0x8f, 0x0e, 0xcd, 0xa7, 0xf2, 0x9b, 0x3c, 0xbe, 0x6b, 0x4c,
+	0xc0, 0x13, 0xb2, 0xc7, 0x61, 0x7c, 0x0d, 0x90, 0xee, 0x8f, 0x89, 0xe7, 0xf2, 0x3d, 0xd9, 0x77,
+	0x89, 0x4e, 0xe5, 0xb7, 0x04, 0x55, 0xe0, 0x9d, 0x08, 0x66, 0x4b, 0xc2, 0x7f, 0x62, 0x0e, 0x83,
+	0xc8, 0xe2, 0x55, 0xb1, 0x24, 0x38, 0x16, 0x5a, 0xdb, 0x01, 0xc4, 0x42, 0x91, 0xea, 0x78, 0x87,
+	0xd3, 0xaa, 0xee, 0xd8, 0x4d, 0xf6, 0xfb, 0x06, 0xac, 0x32, 0xe6, 0xac, 0xd3, 0x6b, 0xa2, 0x20,
+	0x73, 0xc7, 0x89, 0x1e, 0x6f, 0xc1, 0x05, 0x46, 0x9a, 0xd0, 0x80, 0x18, 0x24, 0x20, 0x09, 0xf6,
+	0xbb, 0x9c, 0xcd, 0xe2, 0x7e, 0x14, 0x0a, 0x53, 0x7e, 0x7a, 0xd3, 0x93, 0xd3, 0x38, 0xb3, 0x6e,
+	0x08, 0x3f, 0x19, 0x16, 0xe5, 0xd6, 0xf7, 0x56, 0x74, 0xd7, 0xf6, 0xa0, 0x92, 0x4c, 0x7c, 0x5c,
+	0x02, 0x91, 0xfa, 0x48, 0x62, 0x55, 0x50, 0xb3, 0xdb, 0x62, 0xf5, 0xcb, 0xe7, 0x0a, 0xca, 0xb0,
+	0x3a, 0xea, 0xb0, 0x3d, 0x50, 0x34, 0xf5, 0xb8, 0x33, 0x68, 0x1f, 0x29, 0x28, 0x9b, 0x28, 0xd8,
+	0x1f, 0xe4, 0x8a, 0x6f, 0xa3, 0xab, 0xb5, 0xaf, 0x33, 0x50, 0x4d, 0xdf, 0xc0, 0xf0, 0x8f, 0xe0,
+	0x62, 0xf4, 0x5c, 0xe2, 0xd3, 0x40, 0x7b, 0x62, 0x7a, 0x7c, 0x45, 0x4e, 0x88, 0x38, 0x1d, 0xe3,
+	0x9c, 0xd8, 0x0c, 0x59, 0x7d, 0x1a, 0x7c, 0x62, 0x7a, 0x6c, 0xbd, 0x4d, 0x48, 0x80, 0x0f, 0xe1,
+	0xb2, 0xed, 0x68, 0x7e, 0x40, 0x6c, 0x83, 0x78, 0x86, 0x36, 0x7b, 0xa8, 0xd2, 0x88, 0xae, 0x53,
+	0xdf, 0x77, 0xc4, 0x49, 0x18, 0x5b, 0x79, 0xd5, 0x76, 0xfa, 0x21, 0x79, 0x76, 0x44, 0x34, 0x42,
+	0xea, 0x5c, 0xfe, 0x66, 0xcf, 0xca, 0xdf, 0x57, 0xa0, 0x34, 0x21, 0xae, 0x46, 0xed, 0xc0, 0x3b,
+	0xe5, 0x75, 0x77, 0x51, 0x2d, 0x4e, 0x88, 0xab, 0xb0, 0xf6, 0x0b, 0xb9, 0xfe, 0x3c, 0xc8, 0x15,
+	0x8b, 0xa8, 0xf4, 0x20, 0x57, 0x2c, 0x21, 0xa8, 0xfd, 0x33, 0x0b, 0x95, 0x64, 0x1d, 0xce, 0xae,
+	0x35, 0x3a, 0x3f, 0xb2, 0x24, 0xbe, 0xa9, 0xbd, 0xf1, 0x8d, 0x55, 0x7b, 0xbd, 0xc9, 0xce, 0xb2,
+	0xbd, 0x82, 0xa8, 0x8e, 0x55, 0xa1, 0xc9, 0xea, 0x08, 0x96, 0x6c, 0x54, 0x54, 0x23, 0x45, 0x35,
+	0x6c, 0xe1, 0x03, 0x28, 0x3c, 0xf4, 0xb9, 0xed, 0x02, 0xb7, 0xfd, 0xe6, 0x37, 0xdb, 0x7e, 0xd0,
+	0xe7, 0xc6, 0x4b, 0x0f, 0xfa, 0x5a, 0xa7, 0xab, 0x1e, 0x35, 0x0e, 0xd5, 0x50, 0x1d, 0x5f, 0x82,
+	0x9c, 0x45, 0xbe, 0x3c, 0x4d, 0x9f, 0x7a, 0x1c, 0x3a, 0xef, 0x24, 0x5c, 0x82, 0xdc, 0x13, 0x4a,
+	0x1e, 0xa5, 0xcf, 0x1a, 0x0e, 0x7d, 0x8f, 0x8b, 0x61, 0x17, 0xf2, 0x3c, 0x5e, 0x18, 0x20, 0x8c,
+	0x18, 0x7a, 0x09, 0x17, 0x21, 0xd7, 0xec, 0xaa, 0x6c, 0x41, 0x20, 0xa8, 0x08, 0x54, 0xeb, 0xb5,
+	0x95, 0xa6, 0x82, 0x32, 0xb5, 0xdb, 0x50, 0x10, 0x41, 0x60, 0x8b, 0x25, 0x0e, 0x03, 0x7a, 0x29,
+	0x6c, 0x86, 0x36, 0xa4, 0x48, 0x7a, 0x7c, 0xb4, 0xaf, 0xa8, 0x28, 0x93, 0x9e, 0xea, 0x1c, 0xca,
+	0xd7, 0x7c, 0xa8, 0x24, 0x0b, 0xf1, 0x17, 0x73, 0xc9, 0xfe, 0x9b, 0x04, 0xe5, 0x44, 0x61, 0xcd,
+	0x2a, 0x22, 0x62, 0x59, 0xce, 0x13, 0x8d, 0x58, 0x26, 0xf1, 0xc3, 0xd4, 0x00, 0x0e, 0x35, 0x18,
+	0x72, 0xde, 0xa9, 0x7b, 0x41, 0x4b, 0x24, 0x8f, 0x0a, 0xb5, 0x3f, 0x4a, 0x80, 0xe6, 0x2b, 0xdb,
+	0x39, 0x37, 0xa5, 0x1f, 0xd2, 0xcd, 0xda, 0x1f, 0x24, 0xa8, 0xa6, 0xcb, 0xd9, 0x39, 0xf7, 0xae,
+	0xfc, 0xa0, 0xee, 0xfd, 0x23, 0x03, 0xab, 0xa9, 0x22, 0xf6, 0xbc, 0xde, 0x7d, 0x01, 0xeb, 0xa6,
+	0x41, 0x27, 0xae, 0x13, 0x50, 0x5b, 0x3f, 0xd5, 0x2c, 0xfa, 0x98, 0x5a, 0x72, 0x8d, 0x6f, 0x1a,
+	0xbb, 0xdf, 0x5c, 0x26, 0xd7, 0xdb, 0x33, 0xbd, 0x43, 0xa6, 0xb6, 0xb7, 0xd1, 0x6e, 0x29, 0x47,
+	0xbd, 0xee, 0x40, 0xe9, 0x34, 0x3f, 0xd3, 0x8e, 0x3b, 0x3f, 0xed, 0x74, 0x3f, 0xe9, 0xa8, 0xc8,
+	0x9c, 0xa3, 0x7d, 0x8f, 0xcb, 0xbe, 0x07, 0x68, 0xde, 0x29, 0x7c, 0x11, 0x96, 0xb9, 0x85, 0x5e,
+	0xc2, 0x1b, 0xb0, 0xd6, 0xe9, 0x6a, 0xfd, 0x76, 0x4b, 0xd1, 0x94, 0xfb, 0xf7, 0x95, 0xe6, 0xa0,
+	0x2f, 0x1e, 0x3e, 0x62, 0xf6, 0x20, 0xb5, 0xc0, 0x6b, 0xbf, 0xcf, 0xc2, 0xc6, 0x12, 0x4f, 0x70,
+	0x23, 0xbc, 0xb2, 0x88, 0x5b, 0xd4, 0x8d, 0xf3, 0x78, 0x5f, 0x67, 0x35, 0x43, 0x8f, 0x78, 0x41,
+	0x78, 0xc3, 0xb9, 0x06, 0x2c, 0x4a, 0x76, 0x60, 0x0e, 0x4d, 0xea, 0x85, 0xef, 0x44, 0xe2, 0x1e,
+	0xb3, 0x36, 0xc3, 0xc5, 0x53, 0xd1, 0xbb, 0x80, 0x5d, 0xc7, 0x37, 0x03, 0xf3, 0x31, 0xd5, 0x4c,
+	0x3b, 0x7a, 0x54, 0x62, 0xf7, 0x9a, 0x9c, 0x8a, 0x22, 0x49, 0xdb, 0x0e, 0x62, 0xb6, 0x4d, 0x47,
+	0x64, 0x8e, 0xcd, 0x36, 0xf3, 0xac, 0x8a, 0x22, 0x49, 0xcc, 0xbe, 0x02, 0x15, 0xc3, 0x99, 0xb2,
+	0x62, 0x4f, 0xf0, 0xd8, 0xd9, 0x21, 0xa9, 0x65, 0x81, 0xc5, 0x94, 0xb0, 0x8c, 0x9f, 0xbd, 0x66,
+	0x55, 0xd4, 0xb2, 0xc0, 0x04, 0xe5, 0x2a, 0xac, 0x91, 0xd1, 0xc8, 0x63, 0xc6, 0x23, 0x43, 0xe2,
+	0x62, 0x52, 0x8d, 0x61, 0x4e, 0xdc, 0x7a, 0x00, 0xc5, 0x28, 0x0e, 0xec, 0xa8, 0x66, 0x91, 0xd0,
+	0x5c, 0x71, 0xdb, 0xce, 0xec, 0x94, 0xd4, 0xa2, 0x1d, 0x09, 0xaf, 0x40, 0xc5, 0xf4, 0xb5, 0xd9,
+	0xe3, 0x7c, 0x66, 0x3b, 0xb3, 0x53, 0x54, 0xcb, 0xa6, 0x1f, 0x3f, 0x6c, 0xd6, 0xbe, 0xca, 0x40,
+	0x35, 0xfd, 0x71, 0x01, 0xb7, 0xa0, 0x68, 0x39, 0x3a, 0xe1, 0xa9, 0x25, 0xbe, 0x6c, 0xed, 0x3c,
+	0xe7, 0x7b, 0x44, 0xfd, 0x30, 0xe4, 0xab, 0xb1, 0xe6, 0xd6, 0xdf, 0x25, 0x28, 0x46, 0x30, 0xbe,
+	0x00, 0x39, 0x97, 0x04, 0x63, 0x6e, 0x2e, 0xbf, 0x9f, 0x41, 0x92, 0xca, 0xdb, 0x0c, 0xf7, 0x5d,
+	0x62, 0xf3, 0x14, 0x08, 0x71, 0xd6, 0x66, 0xf3, 0x6a, 0x51, 0x62, 0xf0, 0x5b, 0x8f, 0x33, 0x99,
+	0x50, 0x3b, 0xf0, 0xa3, 0x79, 0x0d, 0xf1, 0x66, 0x08, 0xe3, 0x77, 0x60, 0x3d, 0xf0, 0x88, 0x69,
+	0xa5, 0xb8, 0x39, 0xce, 0x45, 0x91, 0x20, 0x26, 0xef, 0xc1, 0xa5, 0xc8, 0xae, 0x41, 0x03, 0xa2,
+	0x8f, 0xa9, 0x31, 0x53, 0x2a, 0xf0, 0xd7, 0x8d, 0x8b, 0x21, 0xa1, 0x15, 0xca, 0x23, 0xdd, 0xda,
+	0xd7, 0x12, 0xac, 0x47, 0xf7, 0x34, 0x23, 0x0e, 0xd6, 0x11, 0x00, 0xb1, 0x6d, 0x27, 0x48, 0x86,
+	0x6b, 0x31, 0x95, 0x17, 0xf4, 0xea, 0x8d, 0x58, 0x49, 0x4d, 0x18, 0xd8, 0x9a, 0x00, 0xcc, 0x24,
+	0x67, 0x86, 0xed, 0x32, 0x94, 0xc3, 0x2f, 0x47, 0xfc, 0xf3, 0xa3, 0xb8, 0xd9, 0x83, 0x80, 0xd8,
+	0x85, 0x0e, 0x6f, 0x42, 0xfe, 0x84, 0x8e, 0x4c, 0x3b, 0x7c, 0x0f, 0x16, 0x8d, 0xe8, 0xfd, 0x25,
+	0x17, 0xbf, 0xbf, 0xec, 0xff, 0x46, 0x82, 0x0d, 0xdd, 0x99, 0xcc, 0xfb, 0xbb, 0x8f, 0xe6, 0x9e,
+	0x17, 0xfc, 0x8f, 0xa5, 0xcf, 0x3f, 0x1a, 0x99, 0xc1, 0x78, 0x7a, 0x52, 0xd7, 0x9d, 0xc9, 0xee,
+	0xc8, 0xb1, 0x88, 0x3d, 0x9a, 0x7d, 0x3f, 0xe5, 0x7f, 0xf4, 0x1b, 0x23, 0x6a, 0xdf, 0x18, 0x39,
+	0x89, 0xaf, 0xa9, 0xf7, 0x66, 0x7f, 0xff, 0x27, 0x49, 0x7f, 0xca, 0x64, 0x0f, 0x7a, 0xfb, 0x7f,
+	0xce, 0x6c, 0x1d, 0x88, 0xee, 0x7a, 0x51, 0x78, 0x54, 0x3a, 0xb4, 0xa8, 0xce, 0x86, 0xfc, 0xff,
+	0x00, 0x00, 0x00, 0xff, 0xff, 0x3e, 0xe8, 0xef, 0xc4, 0x9b, 0x1d, 0x00, 0x00,
 }
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
new file mode 100644
index 0000000..ed08fcb
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
@@ -0,0 +1,883 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// The messages in this file describe the definitions found in .proto files.
+// A valid .proto file can be translated directly to a FileDescriptorProto
+// without any other information (e.g. without reading its imports).
+
+
+syntax = "proto2";
+
+package google.protobuf;
+option go_package = "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "DescriptorProtos";
+option csharp_namespace = "Google.Protobuf.Reflection";
+option objc_class_prefix = "GPB";
+option cc_enable_arenas = true;
+
+// descriptor.proto must be optimized for speed because reflection-based
+// algorithms don't work during bootstrapping.
+option optimize_for = SPEED;
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+message FileDescriptorSet {
+  repeated FileDescriptorProto file = 1;
+}
+
+// Describes a complete .proto file.
+message FileDescriptorProto {
+  optional string name = 1;       // file name, relative to root of source tree
+  optional string package = 2;    // e.g. "foo", "foo.bar", etc.
+
+  // Names of files imported by this file.
+  repeated string dependency = 3;
+  // Indexes of the public imported files in the dependency list above.
+  repeated int32 public_dependency = 10;
+  // Indexes of the weak imported files in the dependency list.
+  // For Google-internal migration only. Do not use.
+  repeated int32 weak_dependency = 11;
+
+  // All top-level definitions in this file.
+  repeated DescriptorProto message_type = 4;
+  repeated EnumDescriptorProto enum_type = 5;
+  repeated ServiceDescriptorProto service = 6;
+  repeated FieldDescriptorProto extension = 7;
+
+  optional FileOptions options = 8;
+
+  // This field contains optional information about the original source code.
+  // You may safely remove this entire field without harming runtime
+  // functionality of the descriptors -- the information is needed only by
+  // development tools.
+  optional SourceCodeInfo source_code_info = 9;
+
+  // The syntax of the proto file.
+  // The supported values are "proto2" and "proto3".
+  optional string syntax = 12;
+}
+
+// Describes a message type.
+message DescriptorProto {
+  optional string name = 1;
+
+  repeated FieldDescriptorProto field = 2;
+  repeated FieldDescriptorProto extension = 6;
+
+  repeated DescriptorProto nested_type = 3;
+  repeated EnumDescriptorProto enum_type = 4;
+
+  message ExtensionRange {
+    optional int32 start = 1;
+    optional int32 end = 2;
+
+    optional ExtensionRangeOptions options = 3;
+  }
+  repeated ExtensionRange extension_range = 5;
+
+  repeated OneofDescriptorProto oneof_decl = 8;
+
+  optional MessageOptions options = 7;
+
+  // Range of reserved tag numbers. Reserved tag numbers may not be used by
+  // fields or extension ranges in the same message. Reserved ranges may
+  // not overlap.
+  message ReservedRange {
+    optional int32 start = 1; // Inclusive.
+    optional int32 end = 2;   // Exclusive.
+  }
+  repeated ReservedRange reserved_range = 9;
+  // Reserved field names, which may not be used by fields in the same message.
+  // A given name may only be reserved once.
+  repeated string reserved_name = 10;
+}
+
+message ExtensionRangeOptions {
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+// Describes a field within a message.
+message FieldDescriptorProto {
+  enum Type {
+    // 0 is reserved for errors.
+    // Order is weird for historical reasons.
+    TYPE_DOUBLE         = 1;
+    TYPE_FLOAT          = 2;
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+    // negative values are likely.
+    TYPE_INT64          = 3;
+    TYPE_UINT64         = 4;
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+    // negative values are likely.
+    TYPE_INT32          = 5;
+    TYPE_FIXED64        = 6;
+    TYPE_FIXED32        = 7;
+    TYPE_BOOL           = 8;
+    TYPE_STRING         = 9;
+    // Tag-delimited aggregate.
+    // Group type is deprecated and not supported in proto3. However, Proto3
+    // implementations should still be able to parse the group wire format and
+    // treat group fields as unknown fields.
+    TYPE_GROUP          = 10;
+    TYPE_MESSAGE        = 11;  // Length-delimited aggregate.
+
+    // New in version 2.
+    TYPE_BYTES          = 12;
+    TYPE_UINT32         = 13;
+    TYPE_ENUM           = 14;
+    TYPE_SFIXED32       = 15;
+    TYPE_SFIXED64       = 16;
+    TYPE_SINT32         = 17;  // Uses ZigZag encoding.
+    TYPE_SINT64         = 18;  // Uses ZigZag encoding.
+  };
+
+  enum Label {
+    // 0 is reserved for errors
+    LABEL_OPTIONAL      = 1;
+    LABEL_REQUIRED      = 2;
+    LABEL_REPEATED      = 3;
+  };
+
+  optional string name = 1;
+  optional int32 number = 3;
+  optional Label label = 4;
+
+  // If type_name is set, this need not be set.  If both this and type_name
+  // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+  optional Type type = 5;
+
+  // For message and enum types, this is the name of the type.  If the name
+  // starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
+  // rules are used to find the type (i.e. first the nested types within this
+  // message are searched, then within the parent, on up to the root
+  // namespace).
+  optional string type_name = 6;
+
+  // For extensions, this is the name of the type being extended.  It is
+  // resolved in the same manner as type_name.
+  optional string extendee = 2;
+
+  // For numeric types, contains the original text representation of the value.
+  // For booleans, "true" or "false".
+  // For strings, contains the default text contents (not escaped in any way).
+  // For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
+  // TODO(kenton):  Base-64 encode?
+  optional string default_value = 7;
+
+  // If set, gives the index of a oneof in the containing type's oneof_decl
+  // list.  This field is a member of that oneof.
+  optional int32 oneof_index = 9;
+
+  // JSON name of this field. The value is set by protocol compiler. If the
+  // user has set a "json_name" option on this field, that option's value
+  // will be used. Otherwise, it's deduced from the field's name by converting
+  // it to camelCase.
+  optional string json_name = 10;
+
+  optional FieldOptions options = 8;
+}
+
+// Describes a oneof.
+message OneofDescriptorProto {
+  optional string name = 1;
+  optional OneofOptions options = 2;
+}
+
+// Describes an enum type.
+message EnumDescriptorProto {
+  optional string name = 1;
+
+  repeated EnumValueDescriptorProto value = 2;
+
+  optional EnumOptions options = 3;
+
+  // Range of reserved numeric values. Reserved values may not be used by
+  // entries in the same enum. Reserved ranges may not overlap.
+  //
+  // Note that this is distinct from DescriptorProto.ReservedRange in that it
+  // is inclusive such that it can appropriately represent the entire int32
+  // domain.
+  message EnumReservedRange {
+    optional int32 start = 1; // Inclusive.
+    optional int32 end = 2;   // Inclusive.
+  }
+
+  // Range of reserved numeric values. Reserved numeric values may not be used
+  // by enum values in the same enum declaration. Reserved ranges may not
+  // overlap.
+  repeated EnumReservedRange reserved_range = 4;
+
+  // Reserved enum value names, which may not be reused. A given name may only
+  // be reserved once.
+  repeated string reserved_name = 5;
+}
+
+// Describes a value within an enum.
+message EnumValueDescriptorProto {
+  optional string name = 1;
+  optional int32 number = 2;
+
+  optional EnumValueOptions options = 3;
+}
+
+// Describes a service.
+message ServiceDescriptorProto {
+  optional string name = 1;
+  repeated MethodDescriptorProto method = 2;
+
+  optional ServiceOptions options = 3;
+}
+
+// Describes a method of a service.
+message MethodDescriptorProto {
+  optional string name = 1;
+
+  // Input and output type names.  These are resolved in the same way as
+  // FieldDescriptorProto.type_name, but must refer to a message type.
+  optional string input_type = 2;
+  optional string output_type = 3;
+
+  optional MethodOptions options = 4;
+
+  // Identifies if client streams multiple client messages
+  optional bool client_streaming = 5 [default=false];
+  // Identifies if server streams multiple server messages
+  optional bool server_streaming = 6 [default=false];
+}
+
+
+// ===================================================================
+// Options
+
+// Each of the definitions above may have "options" attached.  These are
+// just annotations which may cause code to be generated slightly differently
+// or may contain hints for code that manipulates protocol messages.
+//
+// Clients may define custom options as extensions of the *Options messages.
+// These extensions may not yet be known at parsing time, so the parser cannot
+// store the values in them.  Instead it stores them in a field in the *Options
+// message called uninterpreted_option. This field must have the same name
+// across all *Options messages. We then use this field to populate the
+// extensions when we build a descriptor, at which point all protos have been
+// parsed and so all extensions are known.
+//
+// Extension numbers for custom options may be chosen as follows:
+// * For options which will only be used within a single application or
+//   organization, or for experimental options, use field numbers 50000
+//   through 99999.  It is up to you to ensure that you do not use the
+//   same number for multiple options.
+// * For options which will be published and used publicly by multiple
+//   independent entities, e-mail protobuf-global-extension-registry@google.com
+//   to reserve extension numbers. Simply provide your project name (e.g.
+//   Objective-C plugin) and your project website (if available) -- there's no
+//   need to explain how you intend to use them. Usually you only need one
+//   extension number. You can declare multiple options with only one extension
+//   number by putting them in a sub-message. See the Custom Options section of
+//   the docs for examples:
+//   https://developers.google.com/protocol-buffers/docs/proto#options
+//   If this turns out to be popular, a web service will be set up
+//   to automatically assign option numbers.
+
+
+message FileOptions {
+
+  // Sets the Java package where classes generated from this .proto will be
+  // placed.  By default, the proto package is used, but this is often
+  // inappropriate because proto packages do not normally start with backwards
+  // domain names.
+  optional string java_package = 1;
+
+
+  // If set, all the classes from the .proto file are wrapped in a single
+  // outer class with the given name.  This applies to both Proto1
+  // (equivalent to the old "--one_java_file" option) and Proto2 (where
+  // a .proto always translates to a single class, but you may want to
+  // explicitly choose the class name).
+  optional string java_outer_classname = 8;
+
+  // If set true, then the Java code generator will generate a separate .java
+  // file for each top-level message, enum, and service defined in the .proto
+  // file.  Thus, these types will *not* be nested inside the outer class
+  // named by java_outer_classname.  However, the outer class will still be
+  // generated to contain the file's getDescriptor() method as well as any
+  // top-level extensions defined in the file.
+  optional bool java_multiple_files = 10 [default=false];
+
+  // This option does nothing.
+  optional bool java_generate_equals_and_hash = 20 [deprecated=true];
+
+  // If set true, then the Java2 code generator will generate code that
+  // throws an exception whenever an attempt is made to assign a non-UTF-8
+  // byte sequence to a string field.
+  // Message reflection will do the same.
+  // However, an extension field still accepts non-UTF-8 byte sequences.
+  // This option has no effect on when used with the lite runtime.
+  optional bool java_string_check_utf8 = 27 [default=false];
+
+
+  // Generated classes can be optimized for speed or code size.
+  enum OptimizeMode {
+    SPEED = 1;        // Generate complete code for parsing, serialization,
+                      // etc.
+    CODE_SIZE = 2;    // Use ReflectionOps to implement these methods.
+    LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
+  }
+  optional OptimizeMode optimize_for = 9 [default=SPEED];
+
+  // Sets the Go package where structs generated from this .proto will be
+  // placed. If omitted, the Go package will be derived from the following:
+  //   - The basename of the package import path, if provided.
+  //   - Otherwise, the package statement in the .proto file, if present.
+  //   - Otherwise, the basename of the .proto file, without extension.
+  optional string go_package = 11;
+
+
+
+  // Should generic services be generated in each language?  "Generic" services
+  // are not specific to any particular RPC system.  They are generated by the
+  // main code generators in each language (without additional plugins).
+  // Generic services were the only kind of service generation supported by
+  // early versions of google.protobuf.
+  //
+  // Generic services are now considered deprecated in favor of using plugins
+  // that generate code specific to your particular RPC system.  Therefore,
+  // these default to false.  Old code which depends on generic services should
+  // explicitly set them to true.
+  optional bool cc_generic_services = 16 [default=false];
+  optional bool java_generic_services = 17 [default=false];
+  optional bool py_generic_services = 18 [default=false];
+  optional bool php_generic_services = 42 [default=false];
+
+  // Is this file deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for everything in the file, or it will be completely ignored; in the very
+  // least, this is a formalization for deprecating files.
+  optional bool deprecated = 23 [default=false];
+
+  // Enables the use of arenas for the proto messages in this file. This applies
+  // only to generated classes for C++.
+  optional bool cc_enable_arenas = 31 [default=false];
+
+
+  // Sets the objective c class prefix which is prepended to all objective c
+  // generated classes from this .proto. There is no default.
+  optional string objc_class_prefix = 36;
+
+  // Namespace for generated classes; defaults to the package.
+  optional string csharp_namespace = 37;
+
+  // By default Swift generators will take the proto package and CamelCase it
+  // replacing '.' with underscore and use that to prefix the types/symbols
+  // defined. When this options is provided, they will use this value instead
+  // to prefix the types/symbols defined.
+  optional string swift_prefix = 39;
+
+  // Sets the php class prefix which is prepended to all php generated classes
+  // from this .proto. Default is empty.
+  optional string php_class_prefix = 40;
+
+  // Use this option to change the namespace of php generated classes. Default
+  // is empty. When this option is empty, the package name will be used for
+  // determining the namespace.
+  optional string php_namespace = 41;
+
+
+  // Use this option to change the namespace of php generated metadata classes.
+  // Default is empty. When this option is empty, the proto file name will be used
+  // for determining the namespace.
+  optional string php_metadata_namespace = 44;
+
+  // Use this option to change the package of ruby generated classes. Default
+  // is empty. When this option is not set, the package name will be used for
+  // determining the ruby package.
+  optional string ruby_package = 45;
+
+  // The parser stores options it doesn't recognize here.
+  // See the documentation for the "Options" section above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message.
+  // See the documentation for the "Options" section above.
+  extensions 1000 to max;
+
+  reserved 38;
+}
+
+message MessageOptions {
+  // Set true to use the old proto1 MessageSet wire format for extensions.
+  // This is provided for backwards-compatibility with the MessageSet wire
+  // format.  You should not use this for any other reason:  It's less
+  // efficient, has fewer features, and is more complicated.
+  //
+  // The message must be defined exactly as follows:
+  //   message Foo {
+  //     option message_set_wire_format = true;
+  //     extensions 4 to max;
+  //   }
+  // Note that the message cannot have any defined fields; MessageSets only
+  // have extensions.
+  //
+  // All extensions of your type must be singular messages; e.g. they cannot
+  // be int32s, enums, or repeated messages.
+  //
+  // Because this is an option, the above two restrictions are not enforced by
+  // the protocol compiler.
+  optional bool message_set_wire_format = 1 [default=false];
+
+  // Disables the generation of the standard "descriptor()" accessor, which can
+  // conflict with a field of the same name.  This is meant to make migration
+  // from proto1 easier; new code should avoid fields named "descriptor".
+  optional bool no_standard_descriptor_accessor = 2 [default=false];
+
+  // Is this message deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for the message, or it will be completely ignored; in the very least,
+  // this is a formalization for deprecating messages.
+  optional bool deprecated = 3 [default=false];
+
+  // Whether the message is an automatically generated map entry type for the
+  // maps field.
+  //
+  // For maps fields:
+  //     map<KeyType, ValueType> map_field = 1;
+  // The parsed descriptor looks like:
+  //     message MapFieldEntry {
+  //         option map_entry = true;
+  //         optional KeyType key = 1;
+  //         optional ValueType value = 2;
+  //     }
+  //     repeated MapFieldEntry map_field = 1;
+  //
+  // Implementations may choose not to generate the map_entry=true message, but
+  // use a native map in the target language to hold the keys and values.
+  // The reflection APIs in such implementions still need to work as
+  // if the field is a repeated message field.
+  //
+  // NOTE: Do not set the option in .proto files. Always use the maps syntax
+  // instead. The option should only be implicitly set by the proto compiler
+  // parser.
+  optional bool map_entry = 7;
+
+  reserved 8;  // javalite_serializable
+  reserved 9;  // javanano_as_lite
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message FieldOptions {
+  // The ctype option instructs the C++ code generator to use a different
+  // representation of the field than it normally would.  See the specific
+  // options below.  This option is not yet implemented in the open source
+  // release -- sorry, we'll try to include it in a future version!
+  optional CType ctype = 1 [default = STRING];
+  enum CType {
+    // Default mode.
+    STRING = 0;
+
+    CORD = 1;
+
+    STRING_PIECE = 2;
+  }
+  // The packed option can be enabled for repeated primitive fields to enable
+  // a more efficient representation on the wire. Rather than repeatedly
+  // writing the tag and type for each element, the entire array is encoded as
+  // a single length-delimited blob. In proto3, only explicit setting it to
+  // false will avoid using packed encoding.
+  optional bool packed = 2;
+
+  // The jstype option determines the JavaScript type used for values of the
+  // field.  The option is permitted only for 64 bit integral and fixed types
+  // (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
+  // is represented as JavaScript string, which avoids loss of precision that
+  // can happen when a large value is converted to a floating point JavaScript.
+  // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
+  // use the JavaScript "number" type.  The behavior of the default option
+  // JS_NORMAL is implementation dependent.
+  //
+  // This option is an enum to permit additional types to be added, e.g.
+  // goog.math.Integer.
+  optional JSType jstype = 6 [default = JS_NORMAL];
+  enum JSType {
+    // Use the default type.
+    JS_NORMAL = 0;
+
+    // Use JavaScript strings.
+    JS_STRING = 1;
+
+    // Use JavaScript numbers.
+    JS_NUMBER = 2;
+  }
+
+  // Should this field be parsed lazily?  Lazy applies only to message-type
+  // fields.  It means that when the outer message is initially parsed, the
+  // inner message's contents will not be parsed but instead stored in encoded
+  // form.  The inner message will actually be parsed when it is first accessed.
+  //
+  // This is only a hint.  Implementations are free to choose whether to use
+  // eager or lazy parsing regardless of the value of this option.  However,
+  // setting this option true suggests that the protocol author believes that
+  // using lazy parsing on this field is worth the additional bookkeeping
+  // overhead typically needed to implement it.
+  //
+  // This option does not affect the public interface of any generated code;
+  // all method signatures remain the same.  Furthermore, thread-safety of the
+  // interface is not affected by this option; const methods remain safe to
+  // call from multiple threads concurrently, while non-const methods continue
+  // to require exclusive access.
+  //
+  //
+  // Note that implementations may choose not to check required fields within
+  // a lazy sub-message.  That is, calling IsInitialized() on the outer message
+  // may return true even if the inner message has missing required fields.
+  // This is necessary because otherwise the inner message would have to be
+  // parsed in order to perform the check, defeating the purpose of lazy
+  // parsing.  An implementation which chooses not to check required fields
+  // must be consistent about it.  That is, for any particular sub-message, the
+  // implementation must either *always* check its required fields, or *never*
+  // check its required fields, regardless of whether or not the message has
+  // been parsed.
+  optional bool lazy = 5 [default=false];
+
+  // Is this field deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for accessors, or it will be completely ignored; in the very least, this
+  // is a formalization for deprecating fields.
+  optional bool deprecated = 3 [default=false];
+
+  // For Google-internal migration only. Do not use.
+  optional bool weak = 10 [default=false];
+
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+
+  reserved 4;  // removed jtype
+}
+
+message OneofOptions {
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message EnumOptions {
+
+  // Set this option to true to allow mapping different tag names to the same
+  // value.
+  optional bool allow_alias = 2;
+
+  // Is this enum deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for the enum, or it will be completely ignored; in the very least, this
+  // is a formalization for deprecating enums.
+  optional bool deprecated = 3 [default=false];
+
+  reserved 5;  // javanano_as_lite
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message EnumValueOptions {
+  // Is this enum value deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for the enum value, or it will be completely ignored; in the very least,
+  // this is a formalization for deprecating enum values.
+  optional bool deprecated = 1 [default=false];
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message ServiceOptions {
+
+  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
+  //   framework.  We apologize for hoarding these numbers to ourselves, but
+  //   we were already using them long before we decided to release Protocol
+  //   Buffers.
+
+  // Is this service deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for the service, or it will be completely ignored; in the very least,
+  // this is a formalization for deprecating services.
+  optional bool deprecated = 33 [default=false];
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message MethodOptions {
+
+  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
+  //   framework.  We apologize for hoarding these numbers to ourselves, but
+  //   we were already using them long before we decided to release Protocol
+  //   Buffers.
+
+  // Is this method deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for the method, or it will be completely ignored; in the very least,
+  // this is a formalization for deprecating methods.
+  optional bool deprecated = 33 [default=false];
+
+  // Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
+  // or neither? HTTP based RPC implementation may choose GET verb for safe
+  // methods, and PUT verb for idempotent methods instead of the default POST.
+  enum IdempotencyLevel {
+    IDEMPOTENCY_UNKNOWN = 0;
+    NO_SIDE_EFFECTS     = 1; // implies idempotent
+    IDEMPOTENT          = 2; // idempotent, but may have side effects
+  }
+  optional IdempotencyLevel idempotency_level =
+      34 [default=IDEMPOTENCY_UNKNOWN];
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+
+// A message representing a option the parser does not recognize. This only
+// appears in options protos created by the compiler::Parser class.
+// DescriptorPool resolves these when building Descriptor objects. Therefore,
+// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+// in them.
+message UninterpretedOption {
+  // The name of the uninterpreted option.  Each string represents a segment in
+  // a dot-separated name.  is_extension is true iff a segment represents an
+  // extension (denoted with parentheses in options specs in .proto files).
+  // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
+  // "foo.(bar.baz).qux".
+  message NamePart {
+    required string name_part = 1;
+    required bool is_extension = 2;
+  }
+  repeated NamePart name = 2;
+
+  // The value of the uninterpreted option, in whatever type the tokenizer
+  // identified it as during parsing. Exactly one of these should be set.
+  optional string identifier_value = 3;
+  optional uint64 positive_int_value = 4;
+  optional int64 negative_int_value = 5;
+  optional double double_value = 6;
+  optional bytes string_value = 7;
+  optional string aggregate_value = 8;
+}
+
+// ===================================================================
+// Optional source code info
+
+// Encapsulates information about the original source file from which a
+// FileDescriptorProto was generated.
+message SourceCodeInfo {
+  // A Location identifies a piece of source code in a .proto file which
+  // corresponds to a particular definition.  This information is intended
+  // to be useful to IDEs, code indexers, documentation generators, and similar
+  // tools.
+  //
+  // For example, say we have a file like:
+  //   message Foo {
+  //     optional string foo = 1;
+  //   }
+  // Let's look at just the field definition:
+  //   optional string foo = 1;
+  //   ^       ^^     ^^  ^  ^^^
+  //   a       bc     de  f  ghi
+  // We have the following locations:
+  //   span   path               represents
+  //   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
+  //   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
+  //   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
+  //   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
+  //   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
+  //
+  // Notes:
+  // - A location may refer to a repeated field itself (i.e. not to any
+  //   particular index within it).  This is used whenever a set of elements are
+  //   logically enclosed in a single code segment.  For example, an entire
+  //   extend block (possibly containing multiple extension definitions) will
+  //   have an outer location whose path refers to the "extensions" repeated
+  //   field without an index.
+  // - Multiple locations may have the same path.  This happens when a single
+  //   logical declaration is spread out across multiple places.  The most
+  //   obvious example is the "extend" block again -- there may be multiple
+  //   extend blocks in the same scope, each of which will have the same path.
+  // - A location's span is not always a subset of its parent's span.  For
+  //   example, the "extendee" of an extension declaration appears at the
+  //   beginning of the "extend" block and is shared by all extensions within
+  //   the block.
+  // - Just because a location's span is a subset of some other location's span
+  //   does not mean that it is a descendent.  For example, a "group" defines
+  //   both a type and a field in a single declaration.  Thus, the locations
+  //   corresponding to the type and field and their components will overlap.
+  // - Code which tries to interpret locations should probably be designed to
+  //   ignore those that it doesn't understand, as more types of locations could
+  //   be recorded in the future.
+  repeated Location location = 1;
+  message Location {
+    // Identifies which part of the FileDescriptorProto was defined at this
+    // location.
+    //
+    // Each element is a field number or an index.  They form a path from
+    // the root FileDescriptorProto to the place where the definition.  For
+    // example, this path:
+    //   [ 4, 3, 2, 7, 1 ]
+    // refers to:
+    //   file.message_type(3)  // 4, 3
+    //       .field(7)         // 2, 7
+    //       .name()           // 1
+    // This is because FileDescriptorProto.message_type has field number 4:
+    //   repeated DescriptorProto message_type = 4;
+    // and DescriptorProto.field has field number 2:
+    //   repeated FieldDescriptorProto field = 2;
+    // and FieldDescriptorProto.name has field number 1:
+    //   optional string name = 1;
+    //
+    // Thus, the above path gives the location of a field name.  If we removed
+    // the last element:
+    //   [ 4, 3, 2, 7 ]
+    // this path refers to the whole field declaration (from the beginning
+    // of the label to the terminating semicolon).
+    repeated int32 path = 1 [packed=true];
+
+    // Always has exactly three or four elements: start line, start column,
+    // end line (optional, otherwise assumed same as start line), end column.
+    // These are packed into a single field for efficiency.  Note that line
+    // and column numbers are zero-based -- typically you will want to add
+    // 1 to each before displaying to a user.
+    repeated int32 span = 2 [packed=true];
+
+    // If this SourceCodeInfo represents a complete declaration, these are any
+    // comments appearing before and after the declaration which appear to be
+    // attached to the declaration.
+    //
+    // A series of line comments appearing on consecutive lines, with no other
+    // tokens appearing on those lines, will be treated as a single comment.
+    //
+    // leading_detached_comments will keep paragraphs of comments that appear
+    // before (but not connected to) the current element. Each paragraph,
+    // separated by empty lines, will be one comment element in the repeated
+    // field.
+    //
+    // Only the comment content is provided; comment markers (e.g. //) are
+    // stripped out.  For block comments, leading whitespace and an asterisk
+    // will be stripped from the beginning of each line other than the first.
+    // Newlines are included in the output.
+    //
+    // Examples:
+    //
+    //   optional int32 foo = 1;  // Comment attached to foo.
+    //   // Comment attached to bar.
+    //   optional int32 bar = 2;
+    //
+    //   optional string baz = 3;
+    //   // Comment attached to baz.
+    //   // Another line attached to baz.
+    //
+    //   // Comment attached to qux.
+    //   //
+    //   // Another line attached to qux.
+    //   optional double qux = 4;
+    //
+    //   // Detached comment for corge. This is not leading or trailing comments
+    //   // to qux or corge because there are blank lines separating it from
+    //   // both.
+    //
+    //   // Detached comment for corge paragraph 2.
+    //
+    //   optional string corge = 5;
+    //   /* Block comment attached
+    //    * to corge.  Leading asterisks
+    //    * will be removed. */
+    //   /* Block comment attached to
+    //    * grault. */
+    //   optional int32 grault = 6;
+    //
+    //   // ignored detached comments.
+    optional string leading_comments = 3;
+    optional string trailing_comments = 4;
+    repeated string leading_detached_comments = 6;
+  }
+}
+
+// Describes the relationship between generated code and its original source
+// file. A GeneratedCodeInfo message is associated with only one generated
+// source file, but may contain references to different source .proto files.
+message GeneratedCodeInfo {
+  // An Annotation connects some span of text in generated code to an element
+  // of its generating .proto file.
+  repeated Annotation annotation = 1;
+  message Annotation {
+    // Identifies the element in the original source .proto file. This field
+    // is formatted the same as SourceCodeInfo.Location.path.
+    repeated int32 path = 1 [packed=true];
+
+    // Identifies the filesystem path to the original source .proto.
+    optional string source_file = 2;
+
+    // Identifies the starting offset in bytes in the generated code
+    // that relates to the identified object.
+    optional int32 begin = 3;
+
+    // Identifies the ending offset in bytes in the generated code that
+    // relates to the identified offset. The end offset should be one past
+    // the last relevant byte (so the length of the text = end - begin).
+    optional int32 end = 4;
+  }
+}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go
index 12ff35b..6f4a902 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/generator.go
@@ -1,14 +1,39 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Package generator is deprecated.
-//
-// This package is excluded from the Go protocol buffer compatibility guarantee
-// and may be deleted at some point in the future.
-//
-// Deprecated: Use the "google.golang.org/protobuf/compiler/protogen" package
-// instead to write protoc plugins in Go.
+/*
+	The code generator for the plugin for the Google protocol buffer compiler.
+	It generates Go code from the protocol buffer description files read by the
+	main routine.
+*/
 package generator
 
 import (
@@ -39,13 +64,6 @@
 	plugin "github.com/golang/protobuf/protoc-gen-go/plugin"
 )
 
-func init() {
-	fmt.Fprint(os.Stderr,
-		"WARNING: Package \"github.com/golang/protobuf/protoc-gen-go/generator\" is deprecated.\n"+
-			"\tA future release of golang/protobuf will delete this package,\n"+
-			"\twhich has long been excluded from the compatibility promise.\n\n")
-}
-
 // generatedCodeVersion indicates a version of the generated code.
 // It is incremented whenever an incompatibility between the generated code and
 // proto package is introduced; the generated code references
@@ -2228,8 +2246,7 @@
 		if oneof && oFields[*field.OneofIndex] == nil {
 			odp := message.OneofDecl[int(*field.OneofIndex)]
 			base := CamelCase(odp.GetName())
-			names := allocNames(base, "Get"+base)
-			fname, gname := names[0], names[1]
+			fname := allocNames(base)[0]
 
 			// This is the first field of a oneof we haven't seen before.
 			// Generate the union field.
@@ -2247,7 +2264,7 @@
 			of := oneofField{
 				fieldCommon: fieldCommon{
 					goName:     fname,
-					getterName: gname,
+					getterName: "Get"+fname,
 					goType:     dname,
 					tags:       tag,
 					protoName:  odp.GetName(),
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap.go b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap.go
index e688c89..a9b6103 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/generator/internal/remap/remap.go
@@ -1,9 +1,38 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2017 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Package remap handles tracking the locations of Go tokens in a source text
-// across a rewrite by the Go formatter.
+/*
+Package remap handles tracking the locations of Go tokens in a source text
+across a rewrite by the Go formatter.
+*/
 package remap
 
 import (
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go
index b7b4a2f..61bfc10 100644
--- a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go
@@ -1,75 +1,369 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto
+// source: google/protobuf/compiler/plugin.proto
 
+/*
+Package plugin_go is a generated protocol buffer package.
+
+It is generated from these files:
+	google/protobuf/compiler/plugin.proto
+
+It has these top-level messages:
+	Version
+	CodeGeneratorRequest
+	CodeGeneratorResponse
+*/
 package plugin_go
 
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	pluginpb "google.golang.org/protobuf/types/pluginpb"
-	reflect "reflect"
-)
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
 
-// Symbols defined in public import of google/protobuf/compiler/plugin.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
 
-type CodeGeneratorResponse_Feature = pluginpb.CodeGeneratorResponse_Feature
+// 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
 
-const CodeGeneratorResponse_FEATURE_NONE = pluginpb.CodeGeneratorResponse_FEATURE_NONE
-const CodeGeneratorResponse_FEATURE_PROTO3_OPTIONAL = pluginpb.CodeGeneratorResponse_FEATURE_PROTO3_OPTIONAL
-
-var CodeGeneratorResponse_Feature_name = pluginpb.CodeGeneratorResponse_Feature_name
-var CodeGeneratorResponse_Feature_value = pluginpb.CodeGeneratorResponse_Feature_value
-
-type Version = pluginpb.Version
-type CodeGeneratorRequest = pluginpb.CodeGeneratorRequest
-type CodeGeneratorResponse = pluginpb.CodeGeneratorResponse
-type CodeGeneratorResponse_File = pluginpb.CodeGeneratorResponse_File
-
-var File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawDesc = []byte{
-	0x0a, 0x3c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
-	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69,
-	0x6e, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x25,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f,
-	0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x3b, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
-	0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67,
-	0x6f, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x3b, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x5f,
-	0x67, 0x6f, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32,
+// The version number of protocol compiler.
+type Version struct {
+	Major *int32 `protobuf:"varint,1,opt,name=major" json:"major,omitempty"`
+	Minor *int32 `protobuf:"varint,2,opt,name=minor" json:"minor,omitempty"`
+	Patch *int32 `protobuf:"varint,3,opt,name=patch" json:"patch,omitempty"`
+	// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
+	// be empty for mainline stable releases.
+	Suffix               *string  `protobuf:"bytes,4,opt,name=suffix" json:"suffix,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-var file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
+func (m *Version) Reset()                    { *m = Version{} }
+func (m *Version) String() string            { return proto.CompactTextString(m) }
+func (*Version) ProtoMessage()               {}
+func (*Version) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (m *Version) Unmarshal(b []byte) error {
+	return xxx_messageInfo_Version.Unmarshal(m, b)
+}
+func (m *Version) Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Version.Marshal(b, m, deterministic)
+}
+func (dst *Version) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Version.Merge(dst, src)
+}
+func (m *Version) XXX_Size() int {
+	return xxx_messageInfo_Version.Size(m)
+}
+func (m *Version) XXX_DiscardUnknown() {
+	xxx_messageInfo_Version.DiscardUnknown(m)
 }
 
-func init() { file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_init() }
-func file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_init() {
-	if File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto != nil {
-		return
+var xxx_messageInfo_Version proto.InternalMessageInfo
+
+func (m *Version) GetMajor() int32 {
+	if m != nil && m.Major != nil {
+		return *m.Major
 	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   0,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_goTypes,
-		DependencyIndexes: file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_depIdxs,
-	}.Build()
-	File_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto = out.File
-	file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_rawDesc = nil
-	file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_goTypes = nil
-	file_github_com_golang_protobuf_protoc_gen_go_plugin_plugin_proto_depIdxs = nil
+	return 0
+}
+
+func (m *Version) GetMinor() int32 {
+	if m != nil && m.Minor != nil {
+		return *m.Minor
+	}
+	return 0
+}
+
+func (m *Version) GetPatch() int32 {
+	if m != nil && m.Patch != nil {
+		return *m.Patch
+	}
+	return 0
+}
+
+func (m *Version) GetSuffix() string {
+	if m != nil && m.Suffix != nil {
+		return *m.Suffix
+	}
+	return ""
+}
+
+// An encoded CodeGeneratorRequest is written to the plugin's stdin.
+type CodeGeneratorRequest struct {
+	// The .proto files that were explicitly listed on the command-line.  The
+	// code generator should generate code only for these files.  Each file's
+	// descriptor will be included in proto_file, below.
+	FileToGenerate []string `protobuf:"bytes,1,rep,name=file_to_generate,json=fileToGenerate" json:"file_to_generate,omitempty"`
+	// The generator parameter passed on the command-line.
+	Parameter *string `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"`
+	// FileDescriptorProtos for all files in files_to_generate and everything
+	// they import.  The files will appear in topological order, so each file
+	// appears before any file that imports it.
+	//
+	// protoc guarantees that all proto_files will be written after
+	// the fields above, even though this is not technically guaranteed by the
+	// protobuf wire format.  This theoretically could allow a plugin to stream
+	// in the FileDescriptorProtos and handle them one by one rather than read
+	// the entire set into memory at once.  However, as of this writing, this
+	// is not similarly optimized on protoc's end -- it will store all fields in
+	// memory at once before sending them to the plugin.
+	//
+	// Type names of fields and extensions in the FileDescriptorProto are always
+	// fully qualified.
+	ProtoFile []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file,json=protoFile" json:"proto_file,omitempty"`
+	// The version number of protocol compiler.
+	CompilerVersion      *Version `protobuf:"bytes,3,opt,name=compiler_version,json=compilerVersion" json:"compiler_version,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CodeGeneratorRequest) Reset()                    { *m = CodeGeneratorRequest{} }
+func (m *CodeGeneratorRequest) String() string            { return proto.CompactTextString(m) }
+func (*CodeGeneratorRequest) ProtoMessage()               {}
+func (*CodeGeneratorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+func (m *CodeGeneratorRequest) Unmarshal(b []byte) error {
+	return xxx_messageInfo_CodeGeneratorRequest.Unmarshal(m, b)
+}
+func (m *CodeGeneratorRequest) Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CodeGeneratorRequest.Marshal(b, m, deterministic)
+}
+func (dst *CodeGeneratorRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CodeGeneratorRequest.Merge(dst, src)
+}
+func (m *CodeGeneratorRequest) XXX_Size() int {
+	return xxx_messageInfo_CodeGeneratorRequest.Size(m)
+}
+func (m *CodeGeneratorRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_CodeGeneratorRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CodeGeneratorRequest proto.InternalMessageInfo
+
+func (m *CodeGeneratorRequest) GetFileToGenerate() []string {
+	if m != nil {
+		return m.FileToGenerate
+	}
+	return nil
+}
+
+func (m *CodeGeneratorRequest) GetParameter() string {
+	if m != nil && m.Parameter != nil {
+		return *m.Parameter
+	}
+	return ""
+}
+
+func (m *CodeGeneratorRequest) GetProtoFile() []*google_protobuf.FileDescriptorProto {
+	if m != nil {
+		return m.ProtoFile
+	}
+	return nil
+}
+
+func (m *CodeGeneratorRequest) GetCompilerVersion() *Version {
+	if m != nil {
+		return m.CompilerVersion
+	}
+	return nil
+}
+
+// The plugin writes an encoded CodeGeneratorResponse to stdout.
+type CodeGeneratorResponse struct {
+	// Error message.  If non-empty, code generation failed.  The plugin process
+	// should exit with status code zero even if it reports an error in this way.
+	//
+	// This should be used to indicate errors in .proto files which prevent the
+	// code generator from generating correct code.  Errors which indicate a
+	// problem in protoc itself -- such as the input CodeGeneratorRequest being
+	// unparseable -- should be reported by writing a message to stderr and
+	// exiting with a non-zero status code.
+	Error                *string                       `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
+	File                 []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
+	XXX_unrecognized     []byte                        `json:"-"`
+	XXX_sizecache        int32                         `json:"-"`
+}
+
+func (m *CodeGeneratorResponse) Reset()                    { *m = CodeGeneratorResponse{} }
+func (m *CodeGeneratorResponse) String() string            { return proto.CompactTextString(m) }
+func (*CodeGeneratorResponse) ProtoMessage()               {}
+func (*CodeGeneratorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+func (m *CodeGeneratorResponse) Unmarshal(b []byte) error {
+	return xxx_messageInfo_CodeGeneratorResponse.Unmarshal(m, b)
+}
+func (m *CodeGeneratorResponse) Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CodeGeneratorResponse.Marshal(b, m, deterministic)
+}
+func (dst *CodeGeneratorResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CodeGeneratorResponse.Merge(dst, src)
+}
+func (m *CodeGeneratorResponse) XXX_Size() int {
+	return xxx_messageInfo_CodeGeneratorResponse.Size(m)
+}
+func (m *CodeGeneratorResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_CodeGeneratorResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CodeGeneratorResponse proto.InternalMessageInfo
+
+func (m *CodeGeneratorResponse) GetError() string {
+	if m != nil && m.Error != nil {
+		return *m.Error
+	}
+	return ""
+}
+
+func (m *CodeGeneratorResponse) GetFile() []*CodeGeneratorResponse_File {
+	if m != nil {
+		return m.File
+	}
+	return nil
+}
+
+// Represents a single generated file.
+type CodeGeneratorResponse_File struct {
+	// The file name, relative to the output directory.  The name must not
+	// contain "." or ".." components and must be relative, not be absolute (so,
+	// the file cannot lie outside the output directory).  "/" must be used as
+	// the path separator, not "\".
+	//
+	// If the name is omitted, the content will be appended to the previous
+	// file.  This allows the generator to break large files into small chunks,
+	// and allows the generated text to be streamed back to protoc so that large
+	// files need not reside completely in memory at one time.  Note that as of
+	// this writing protoc does not optimize for this -- it will read the entire
+	// CodeGeneratorResponse before writing files to disk.
+	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	// If non-empty, indicates that the named file should already exist, and the
+	// content here is to be inserted into that file at a defined insertion
+	// point.  This feature allows a code generator to extend the output
+	// produced by another code generator.  The original generator may provide
+	// insertion points by placing special annotations in the file that look
+	// like:
+	//   @@protoc_insertion_point(NAME)
+	// The annotation can have arbitrary text before and after it on the line,
+	// which allows it to be placed in a comment.  NAME should be replaced with
+	// an identifier naming the point -- this is what other generators will use
+	// as the insertion_point.  Code inserted at this point will be placed
+	// immediately above the line containing the insertion point (thus multiple
+	// insertions to the same point will come out in the order they were added).
+	// The double-@ is intended to make it unlikely that the generated code
+	// could contain things that look like insertion points by accident.
+	//
+	// For example, the C++ code generator places the following line in the
+	// .pb.h files that it generates:
+	//   // @@protoc_insertion_point(namespace_scope)
+	// This line appears within the scope of the file's package namespace, but
+	// outside of any particular class.  Another plugin can then specify the
+	// insertion_point "namespace_scope" to generate additional classes or
+	// other declarations that should be placed in this scope.
+	//
+	// Note that if the line containing the insertion point begins with
+	// whitespace, the same whitespace will be added to every line of the
+	// inserted text.  This is useful for languages like Python, where
+	// indentation matters.  In these languages, the insertion point comment
+	// should be indented the same amount as any inserted code will need to be
+	// in order to work correctly in that context.
+	//
+	// The code generator that generates the initial file and the one which
+	// inserts into it must both run as part of a single invocation of protoc.
+	// Code generators are executed in the order in which they appear on the
+	// command line.
+	//
+	// If |insertion_point| is present, |name| must also be present.
+	InsertionPoint *string `protobuf:"bytes,2,opt,name=insertion_point,json=insertionPoint" json:"insertion_point,omitempty"`
+	// The file contents.
+	Content              *string  `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CodeGeneratorResponse_File) Reset()                    { *m = CodeGeneratorResponse_File{} }
+func (m *CodeGeneratorResponse_File) String() string            { return proto.CompactTextString(m) }
+func (*CodeGeneratorResponse_File) ProtoMessage()               {}
+func (*CodeGeneratorResponse_File) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
+func (m *CodeGeneratorResponse_File) Unmarshal(b []byte) error {
+	return xxx_messageInfo_CodeGeneratorResponse_File.Unmarshal(m, b)
+}
+func (m *CodeGeneratorResponse_File) Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CodeGeneratorResponse_File.Marshal(b, m, deterministic)
+}
+func (dst *CodeGeneratorResponse_File) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CodeGeneratorResponse_File.Merge(dst, src)
+}
+func (m *CodeGeneratorResponse_File) XXX_Size() int {
+	return xxx_messageInfo_CodeGeneratorResponse_File.Size(m)
+}
+func (m *CodeGeneratorResponse_File) XXX_DiscardUnknown() {
+	xxx_messageInfo_CodeGeneratorResponse_File.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CodeGeneratorResponse_File proto.InternalMessageInfo
+
+func (m *CodeGeneratorResponse_File) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *CodeGeneratorResponse_File) GetInsertionPoint() string {
+	if m != nil && m.InsertionPoint != nil {
+		return *m.InsertionPoint
+	}
+	return ""
+}
+
+func (m *CodeGeneratorResponse_File) GetContent() string {
+	if m != nil && m.Content != nil {
+		return *m.Content
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*Version)(nil), "google.protobuf.compiler.Version")
+	proto.RegisterType((*CodeGeneratorRequest)(nil), "google.protobuf.compiler.CodeGeneratorRequest")
+	proto.RegisterType((*CodeGeneratorResponse)(nil), "google.protobuf.compiler.CodeGeneratorResponse")
+	proto.RegisterType((*CodeGeneratorResponse_File)(nil), "google.protobuf.compiler.CodeGeneratorResponse.File")
+}
+
+func init() { proto.RegisterFile("google/protobuf/compiler/plugin.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 417 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xcf, 0x6a, 0x14, 0x41,
+	0x10, 0xc6, 0x19, 0x77, 0x63, 0x98, 0x8a, 0x64, 0x43, 0x13, 0xa5, 0x09, 0x39, 0x8c, 0x8b, 0xe2,
+	0x5c, 0x32, 0x0b, 0xc1, 0x8b, 0x78, 0x4b, 0x44, 0x3d, 0x78, 0x58, 0x1a, 0xf1, 0x20, 0xc8, 0x30,
+	0x99, 0xd4, 0x74, 0x5a, 0x66, 0xba, 0xc6, 0xee, 0x1e, 0xf1, 0x49, 0x7d, 0x0f, 0xdf, 0x40, 0xfa,
+	0xcf, 0x24, 0xb2, 0xb8, 0xa7, 0xee, 0xef, 0x57, 0xd5, 0xd5, 0x55, 0x1f, 0x05, 0x2f, 0x25, 0x91,
+	0xec, 0x71, 0x33, 0x1a, 0x72, 0x74, 0x33, 0x75, 0x9b, 0x96, 0x86, 0x51, 0xf5, 0x68, 0x36, 0x63,
+	0x3f, 0x49, 0xa5, 0xab, 0x10, 0x60, 0x3c, 0xa6, 0x55, 0x73, 0x5a, 0x35, 0xa7, 0x9d, 0x15, 0xbb,
+	0x05, 0x6e, 0xd1, 0xb6, 0x46, 0x8d, 0x8e, 0x4c, 0xcc, 0x5e, 0xb7, 0x70, 0xf8, 0x05, 0x8d, 0x55,
+	0xa4, 0xd9, 0x29, 0x1c, 0x0c, 0xcd, 0x77, 0x32, 0x3c, 0x2b, 0xb2, 0xf2, 0x40, 0x44, 0x11, 0xa8,
+	0xd2, 0x64, 0xf8, 0xa3, 0x44, 0xbd, 0xf0, 0x74, 0x6c, 0x5c, 0x7b, 0xc7, 0x17, 0x91, 0x06, 0xc1,
+	0x9e, 0xc1, 0x63, 0x3b, 0x75, 0x9d, 0xfa, 0xc5, 0x97, 0x45, 0x56, 0xe6, 0x22, 0xa9, 0xf5, 0x9f,
+	0x0c, 0x4e, 0xaf, 0xe9, 0x16, 0x3f, 0xa0, 0x46, 0xd3, 0x38, 0x32, 0x02, 0x7f, 0x4c, 0x68, 0x1d,
+	0x2b, 0xe1, 0xa4, 0x53, 0x3d, 0xd6, 0x8e, 0x6a, 0x19, 0x63, 0xc8, 0xb3, 0x62, 0x51, 0xe6, 0xe2,
+	0xd8, 0xf3, 0xcf, 0x94, 0x5e, 0x20, 0x3b, 0x87, 0x7c, 0x6c, 0x4c, 0x33, 0xa0, 0xc3, 0xd8, 0x4a,
+	0x2e, 0x1e, 0x00, 0xbb, 0x06, 0x08, 0xe3, 0xd4, 0xfe, 0x15, 0x5f, 0x15, 0x8b, 0xf2, 0xe8, 0xf2,
+	0x45, 0xb5, 0x6b, 0xcb, 0x7b, 0xd5, 0xe3, 0xbb, 0x7b, 0x03, 0xb6, 0x1e, 0x8b, 0x3c, 0x44, 0x7d,
+	0x84, 0x7d, 0x82, 0x93, 0xd9, 0xb8, 0xfa, 0x67, 0xf4, 0x24, 0x8c, 0x77, 0x74, 0xf9, 0xbc, 0xda,
+	0xe7, 0x70, 0x95, 0xcc, 0x13, 0xab, 0x99, 0x24, 0xb0, 0xfe, 0x9d, 0xc1, 0xd3, 0x9d, 0x99, 0xed,
+	0x48, 0xda, 0xa2, 0xf7, 0x0e, 0x8d, 0x49, 0x3e, 0xe7, 0x22, 0x0a, 0xf6, 0x11, 0x96, 0xff, 0x34,
+	0xff, 0x7a, 0xff, 0x8f, 0xff, 0x2d, 0x1a, 0x66, 0x13, 0xa1, 0xc2, 0xd9, 0x37, 0x58, 0x86, 0x79,
+	0x18, 0x2c, 0x75, 0x33, 0x60, 0xfa, 0x26, 0xdc, 0xd9, 0x2b, 0x58, 0x29, 0x6d, 0xd1, 0x38, 0x45,
+	0xba, 0x1e, 0x49, 0x69, 0x97, 0xcc, 0x3c, 0xbe, 0xc7, 0x5b, 0x4f, 0x19, 0x87, 0xc3, 0x96, 0xb4,
+	0x43, 0xed, 0xf8, 0x2a, 0x24, 0xcc, 0xf2, 0x4a, 0xc2, 0x79, 0x4b, 0xc3, 0xde, 0xfe, 0xae, 0x9e,
+	0x6c, 0xc3, 0x6e, 0x06, 0x7b, 0xed, 0xd7, 0x37, 0x52, 0xb9, 0xbb, 0xe9, 0xc6, 0x87, 0x37, 0x92,
+	0xfa, 0x46, 0xcb, 0x87, 0x65, 0x0c, 0x97, 0xf6, 0x42, 0xa2, 0xbe, 0x90, 0x94, 0x56, 0xfa, 0x6d,
+	0x3c, 0x6a, 0x49, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x15, 0x40, 0xc5, 0xfe, 0x02, 0x00,
+	0x00,
 }
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.golden b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.golden
new file mode 100644
index 0000000..8953d0f
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.golden
@@ -0,0 +1,83 @@
+// Code generated by protoc-gen-go.
+// source: google/protobuf/compiler/plugin.proto
+// DO NOT EDIT!
+
+package google_protobuf_compiler
+
+import proto "github.com/golang/protobuf/proto"
+import "math"
+import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
+
+// Reference proto and math imports to suppress error if they are not otherwise used.
+var _ = proto.GetString
+var _ = math.Inf
+
+type CodeGeneratorRequest struct {
+	FileToGenerate   []string                               `protobuf:"bytes,1,rep,name=file_to_generate" json:"file_to_generate,omitempty"`
+	Parameter        *string                                `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"`
+	ProtoFile        []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file" json:"proto_file,omitempty"`
+	XXX_unrecognized []byte                                 `json:"-"`
+}
+
+func (this *CodeGeneratorRequest) Reset()         { *this = CodeGeneratorRequest{} }
+func (this *CodeGeneratorRequest) String() string { return proto.CompactTextString(this) }
+func (*CodeGeneratorRequest) ProtoMessage()       {}
+
+func (this *CodeGeneratorRequest) GetParameter() string {
+	if this != nil && this.Parameter != nil {
+		return *this.Parameter
+	}
+	return ""
+}
+
+type CodeGeneratorResponse struct {
+	Error            *string                       `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
+	File             []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"`
+	XXX_unrecognized []byte                        `json:"-"`
+}
+
+func (this *CodeGeneratorResponse) Reset()         { *this = CodeGeneratorResponse{} }
+func (this *CodeGeneratorResponse) String() string { return proto.CompactTextString(this) }
+func (*CodeGeneratorResponse) ProtoMessage()       {}
+
+func (this *CodeGeneratorResponse) GetError() string {
+	if this != nil && this.Error != nil {
+		return *this.Error
+	}
+	return ""
+}
+
+type CodeGeneratorResponse_File struct {
+	Name             *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	InsertionPoint   *string `protobuf:"bytes,2,opt,name=insertion_point" json:"insertion_point,omitempty"`
+	Content          *string `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (this *CodeGeneratorResponse_File) Reset()         { *this = CodeGeneratorResponse_File{} }
+func (this *CodeGeneratorResponse_File) String() string { return proto.CompactTextString(this) }
+func (*CodeGeneratorResponse_File) ProtoMessage()       {}
+
+func (this *CodeGeneratorResponse_File) GetName() string {
+	if this != nil && this.Name != nil {
+		return *this.Name
+	}
+	return ""
+}
+
+func (this *CodeGeneratorResponse_File) GetInsertionPoint() string {
+	if this != nil && this.InsertionPoint != nil {
+		return *this.InsertionPoint
+	}
+	return ""
+}
+
+func (this *CodeGeneratorResponse_File) GetContent() string {
+	if this != nil && this.Content != nil {
+		return *this.Content
+	}
+	return ""
+}
+
+func init() {
+}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto
new file mode 100644
index 0000000..5b55745
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.proto
@@ -0,0 +1,167 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//
+// WARNING:  The plugin interface is currently EXPERIMENTAL and is subject to
+//   change.
+//
+// protoc (aka the Protocol Compiler) can be extended via plugins.  A plugin is
+// just a program that reads a CodeGeneratorRequest from stdin and writes a
+// CodeGeneratorResponse to stdout.
+//
+// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead
+// of dealing with the raw protocol defined here.
+//
+// A plugin executable needs only to be placed somewhere in the path.  The
+// plugin should be named "protoc-gen-$NAME", and will then be used when the
+// flag "--${NAME}_out" is passed to protoc.
+
+syntax = "proto2";
+package google.protobuf.compiler;
+option java_package = "com.google.protobuf.compiler";
+option java_outer_classname = "PluginProtos";
+
+option go_package = "github.com/golang/protobuf/protoc-gen-go/plugin;plugin_go";
+
+import "google/protobuf/descriptor.proto";
+
+// The version number of protocol compiler.
+message Version {
+  optional int32 major = 1;
+  optional int32 minor = 2;
+  optional int32 patch = 3;
+  // A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
+  // be empty for mainline stable releases.
+  optional string suffix = 4;
+}
+
+// An encoded CodeGeneratorRequest is written to the plugin's stdin.
+message CodeGeneratorRequest {
+  // The .proto files that were explicitly listed on the command-line.  The
+  // code generator should generate code only for these files.  Each file's
+  // descriptor will be included in proto_file, below.
+  repeated string file_to_generate = 1;
+
+  // The generator parameter passed on the command-line.
+  optional string parameter = 2;
+
+  // FileDescriptorProtos for all files in files_to_generate and everything
+  // they import.  The files will appear in topological order, so each file
+  // appears before any file that imports it.
+  //
+  // protoc guarantees that all proto_files will be written after
+  // the fields above, even though this is not technically guaranteed by the
+  // protobuf wire format.  This theoretically could allow a plugin to stream
+  // in the FileDescriptorProtos and handle them one by one rather than read
+  // the entire set into memory at once.  However, as of this writing, this
+  // is not similarly optimized on protoc's end -- it will store all fields in
+  // memory at once before sending them to the plugin.
+  //
+  // Type names of fields and extensions in the FileDescriptorProto are always
+  // fully qualified.
+  repeated FileDescriptorProto proto_file = 15;
+
+  // The version number of protocol compiler.
+  optional Version compiler_version = 3;
+
+}
+
+// The plugin writes an encoded CodeGeneratorResponse to stdout.
+message CodeGeneratorResponse {
+  // Error message.  If non-empty, code generation failed.  The plugin process
+  // should exit with status code zero even if it reports an error in this way.
+  //
+  // This should be used to indicate errors in .proto files which prevent the
+  // code generator from generating correct code.  Errors which indicate a
+  // problem in protoc itself -- such as the input CodeGeneratorRequest being
+  // unparseable -- should be reported by writing a message to stderr and
+  // exiting with a non-zero status code.
+  optional string error = 1;
+
+  // Represents a single generated file.
+  message File {
+    // The file name, relative to the output directory.  The name must not
+    // contain "." or ".." components and must be relative, not be absolute (so,
+    // the file cannot lie outside the output directory).  "/" must be used as
+    // the path separator, not "\".
+    //
+    // If the name is omitted, the content will be appended to the previous
+    // file.  This allows the generator to break large files into small chunks,
+    // and allows the generated text to be streamed back to protoc so that large
+    // files need not reside completely in memory at one time.  Note that as of
+    // this writing protoc does not optimize for this -- it will read the entire
+    // CodeGeneratorResponse before writing files to disk.
+    optional string name = 1;
+
+    // If non-empty, indicates that the named file should already exist, and the
+    // content here is to be inserted into that file at a defined insertion
+    // point.  This feature allows a code generator to extend the output
+    // produced by another code generator.  The original generator may provide
+    // insertion points by placing special annotations in the file that look
+    // like:
+    //   @@protoc_insertion_point(NAME)
+    // The annotation can have arbitrary text before and after it on the line,
+    // which allows it to be placed in a comment.  NAME should be replaced with
+    // an identifier naming the point -- this is what other generators will use
+    // as the insertion_point.  Code inserted at this point will be placed
+    // immediately above the line containing the insertion point (thus multiple
+    // insertions to the same point will come out in the order they were added).
+    // The double-@ is intended to make it unlikely that the generated code
+    // could contain things that look like insertion points by accident.
+    //
+    // For example, the C++ code generator places the following line in the
+    // .pb.h files that it generates:
+    //   // @@protoc_insertion_point(namespace_scope)
+    // This line appears within the scope of the file's package namespace, but
+    // outside of any particular class.  Another plugin can then specify the
+    // insertion_point "namespace_scope" to generate additional classes or
+    // other declarations that should be placed in this scope.
+    //
+    // Note that if the line containing the insertion point begins with
+    // whitespace, the same whitespace will be added to every line of the
+    // inserted text.  This is useful for languages like Python, where
+    // indentation matters.  In these languages, the insertion point comment
+    // should be indented the same amount as any inserted code will need to be
+    // in order to work correctly in that context.
+    //
+    // The code generator that generates the initial file and the one which
+    // inserts into it must both run as part of a single invocation of protoc.
+    // Code generators are executed in the order in which they appear on the
+    // command line.
+    //
+    // If |insertion_point| is present, |name| must also be present.
+    optional string insertion_point = 2;
+
+    // The file contents.
+    optional string content = 15;
+  }
+  repeated File file = 15;
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/any.go b/vendor/github.com/golang/protobuf/ptypes/any.go
index e729dcf..70276e8 100644
--- a/vendor/github.com/golang/protobuf/ptypes/any.go
+++ b/vendor/github.com/golang/protobuf/ptypes/any.go
@@ -1,165 +1,141 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 package ptypes
 
+// This file implements functions to marshal proto.Message to/from
+// google.protobuf.Any message.
+
 import (
 	"fmt"
+	"reflect"
 	"strings"
 
 	"github.com/golang/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-
-	anypb "github.com/golang/protobuf/ptypes/any"
+	"github.com/golang/protobuf/ptypes/any"
 )
 
-const urlPrefix = "type.googleapis.com/"
+const googleApis = "type.googleapis.com/"
 
-// AnyMessageName returns the message name contained in an anypb.Any message.
-// Most type assertions should use the Is function instead.
-func AnyMessageName(any *anypb.Any) (string, error) {
-	name, err := anyMessageName(any)
-	return string(name), err
-}
-func anyMessageName(any *anypb.Any) (protoreflect.FullName, error) {
+// AnyMessageName returns the name of the message contained in a google.protobuf.Any message.
+//
+// Note that regular type assertions should be done using the Is
+// function. AnyMessageName is provided for less common use cases like filtering a
+// sequence of Any messages based on a set of allowed message type names.
+func AnyMessageName(any *any.Any) (string, error) {
 	if any == nil {
 		return "", fmt.Errorf("message is nil")
 	}
-	name := protoreflect.FullName(any.TypeUrl)
-	if i := strings.LastIndex(any.TypeUrl, "/"); i >= 0 {
-		name = name[i+len("/"):]
-	}
-	if !name.IsValid() {
+	slash := strings.LastIndex(any.TypeUrl, "/")
+	if slash < 0 {
 		return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl)
 	}
-	return name, nil
+	return any.TypeUrl[slash+1:], nil
 }
 
-// MarshalAny marshals the given message m into an anypb.Any message.
-func MarshalAny(m proto.Message) (*anypb.Any, error) {
-	switch dm := m.(type) {
-	case DynamicAny:
-		m = dm.Message
-	case *DynamicAny:
-		if dm == nil {
-			return nil, proto.ErrNil
-		}
-		m = dm.Message
-	}
-	b, err := proto.Marshal(m)
+// MarshalAny takes the protocol buffer and encodes it into google.protobuf.Any.
+func MarshalAny(pb proto.Message) (*any.Any, error) {
+	value, err := proto.Marshal(pb)
 	if err != nil {
 		return nil, err
 	}
-	return &anypb.Any{TypeUrl: urlPrefix + proto.MessageName(m), Value: b}, nil
+	return &any.Any{TypeUrl: googleApis + proto.MessageName(pb), Value: value}, nil
 }
 
-// Empty returns a new message of the type specified in an anypb.Any message.
-// It returns protoregistry.NotFound if the corresponding message type could not
-// be resolved in the global registry.
-func Empty(any *anypb.Any) (proto.Message, error) {
-	name, err := anyMessageName(any)
-	if err != nil {
-		return nil, err
-	}
-	mt, err := protoregistry.GlobalTypes.FindMessageByName(name)
-	if err != nil {
-		return nil, err
-	}
-	return proto.MessageV1(mt.New().Interface()), nil
-}
-
-// UnmarshalAny unmarshals the encoded value contained in the anypb.Any message
-// into the provided message m. It returns an error if the target message
-// does not match the type in the Any message or if an unmarshal error occurs.
+// DynamicAny is a value that can be passed to UnmarshalAny to automatically
+// allocate a proto.Message for the type specified in a google.protobuf.Any
+// message. The allocated message is stored in the embedded proto.Message.
 //
-// The target message m may be a *DynamicAny message. If the underlying message
-// type could not be resolved, then this returns protoregistry.NotFound.
-func UnmarshalAny(any *anypb.Any, m proto.Message) error {
-	if dm, ok := m.(*DynamicAny); ok {
-		if dm.Message == nil {
+// Example:
+//
+//   var x ptypes.DynamicAny
+//   if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
+//   fmt.Printf("unmarshaled message: %v", x.Message)
+type DynamicAny struct {
+	proto.Message
+}
+
+// Empty returns a new proto.Message of the type specified in a
+// google.protobuf.Any message. It returns an error if corresponding message
+// type isn't linked in.
+func Empty(any *any.Any) (proto.Message, error) {
+	aname, err := AnyMessageName(any)
+	if err != nil {
+		return nil, err
+	}
+
+	t := proto.MessageType(aname)
+	if t == nil {
+		return nil, fmt.Errorf("any: message type %q isn't linked in", aname)
+	}
+	return reflect.New(t.Elem()).Interface().(proto.Message), nil
+}
+
+// UnmarshalAny parses the protocol buffer representation in a google.protobuf.Any
+// message and places the decoded result in pb. It returns an error if type of
+// contents of Any message does not match type of pb message.
+//
+// pb can be a proto.Message, or a *DynamicAny.
+func UnmarshalAny(any *any.Any, pb proto.Message) error {
+	if d, ok := pb.(*DynamicAny); ok {
+		if d.Message == nil {
 			var err error
-			dm.Message, err = Empty(any)
+			d.Message, err = Empty(any)
 			if err != nil {
 				return err
 			}
 		}
-		m = dm.Message
+		return UnmarshalAny(any, d.Message)
 	}
 
-	anyName, err := AnyMessageName(any)
+	aname, err := AnyMessageName(any)
 	if err != nil {
 		return err
 	}
-	msgName := proto.MessageName(m)
-	if anyName != msgName {
-		return fmt.Errorf("mismatched message type: got %q want %q", anyName, msgName)
+
+	mname := proto.MessageName(pb)
+	if aname != mname {
+		return fmt.Errorf("mismatched message type: got %q want %q", aname, mname)
 	}
-	return proto.Unmarshal(any.Value, m)
+	return proto.Unmarshal(any.Value, pb)
 }
 
-// Is reports whether the Any message contains a message of the specified type.
-func Is(any *anypb.Any, m proto.Message) bool {
-	if any == nil || m == nil {
+// Is returns true if any value contains a given message type.
+func Is(any *any.Any, pb proto.Message) bool {
+	// The following is equivalent to AnyMessageName(any) == proto.MessageName(pb),
+	// but it avoids scanning TypeUrl for the slash.
+	if any == nil {
 		return false
 	}
-	name := proto.MessageName(m)
-	if !strings.HasSuffix(any.TypeUrl, name) {
-		return false
-	}
-	return len(any.TypeUrl) == len(name) || any.TypeUrl[len(any.TypeUrl)-len(name)-1] == '/'
-}
-
-// DynamicAny is a value that can be passed to UnmarshalAny to automatically
-// allocate a proto.Message for the type specified in an anypb.Any message.
-// The allocated message is stored in the embedded proto.Message.
-//
-// Example:
-//   var x ptypes.DynamicAny
-//   if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
-//   fmt.Printf("unmarshaled message: %v", x.Message)
-type DynamicAny struct{ proto.Message }
-
-func (m DynamicAny) String() string {
-	if m.Message == nil {
-		return "<nil>"
-	}
-	return m.Message.String()
-}
-func (m DynamicAny) Reset() {
-	if m.Message == nil {
-		return
-	}
-	m.Message.Reset()
-}
-func (m DynamicAny) ProtoMessage() {
-	return
-}
-func (m DynamicAny) ProtoReflect() protoreflect.Message {
-	if m.Message == nil {
-		return nil
-	}
-	return dynamicAny{proto.MessageReflect(m.Message)}
-}
-
-type dynamicAny struct{ protoreflect.Message }
-
-func (m dynamicAny) Type() protoreflect.MessageType {
-	return dynamicAnyType{m.Message.Type()}
-}
-func (m dynamicAny) New() protoreflect.Message {
-	return dynamicAnyType{m.Message.Type()}.New()
-}
-func (m dynamicAny) Interface() protoreflect.ProtoMessage {
-	return DynamicAny{proto.MessageV1(m.Message.Interface())}
-}
-
-type dynamicAnyType struct{ protoreflect.MessageType }
-
-func (t dynamicAnyType) New() protoreflect.Message {
-	return dynamicAny{t.MessageType.New()}
-}
-func (t dynamicAnyType) Zero() protoreflect.Message {
-	return dynamicAny{t.MessageType.Zero()}
+	name := proto.MessageName(pb)
+	prefix := len(any.TypeUrl) - len(name)
+	return prefix >= 1 && any.TypeUrl[prefix-1] == '/' && any.TypeUrl[prefix:] == name
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
index 0ef27d3..78ee523 100644
--- a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
@@ -1,62 +1,200 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/ptypes/any/any.proto
+// source: google/protobuf/any.proto
 
 package any
 
 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	anypb "google.golang.org/protobuf/types/known/anypb"
-	reflect "reflect"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
 )
 
-// Symbols defined in public import of google/protobuf/any.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
 
-type Any = anypb.Any
+// 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.ProtoPackageIsVersion3 // please upgrade the proto package
 
-var File_github_com_golang_protobuf_ptypes_any_any_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc = []byte{
-	0x0a, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
-	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
-	0x70, 0x65, 0x73, 0x2f, 0x61, 0x6e, 0x79, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
-	0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x2b, 0x5a, 0x29,
-	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e,
-	0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65,
-	0x73, 0x2f, 0x61, 0x6e, 0x79, 0x3b, 0x61, 0x6e, 0x79, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x33,
+// `Any` contains an arbitrary serialized protocol buffer message along with a
+// URL that describes the type of the serialized message.
+//
+// Protobuf library provides support to pack/unpack Any values in the form
+// of utility functions or additional generated methods of the Any type.
+//
+// Example 1: Pack and unpack a message in C++.
+//
+//     Foo foo = ...;
+//     Any any;
+//     any.PackFrom(foo);
+//     ...
+//     if (any.UnpackTo(&foo)) {
+//       ...
+//     }
+//
+// Example 2: Pack and unpack a message in Java.
+//
+//     Foo foo = ...;
+//     Any any = Any.pack(foo);
+//     ...
+//     if (any.is(Foo.class)) {
+//       foo = any.unpack(Foo.class);
+//     }
+//
+//  Example 3: Pack and unpack a message in Python.
+//
+//     foo = Foo(...)
+//     any = Any()
+//     any.Pack(foo)
+//     ...
+//     if any.Is(Foo.DESCRIPTOR):
+//       any.Unpack(foo)
+//       ...
+//
+//  Example 4: Pack and unpack a message in Go
+//
+//      foo := &pb.Foo{...}
+//      any, err := ptypes.MarshalAny(foo)
+//      ...
+//      foo := &pb.Foo{}
+//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+//        ...
+//      }
+//
+// The pack methods provided by protobuf library will by default use
+// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+// methods only use the fully qualified type name after the last '/'
+// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+// name "y.z".
+//
+//
+// JSON
+// ====
+// The JSON representation of an `Any` value uses the regular
+// representation of the deserialized, embedded message, with an
+// additional field `@type` which contains the type URL. Example:
+//
+//     package google.profile;
+//     message Person {
+//       string first_name = 1;
+//       string last_name = 2;
+//     }
+//
+//     {
+//       "@type": "type.googleapis.com/google.profile.Person",
+//       "firstName": <string>,
+//       "lastName": <string>
+//     }
+//
+// If the embedded message type is well-known and has a custom JSON
+// representation, that representation will be embedded adding a field
+// `value` which holds the custom JSON in addition to the `@type`
+// field. Example (for message [google.protobuf.Duration][]):
+//
+//     {
+//       "@type": "type.googleapis.com/google.protobuf.Duration",
+//       "value": "1.212s"
+//     }
+//
+type Any struct {
+	// A URL/resource name that uniquely identifies the type of the serialized
+	// protocol buffer message. The last segment of the URL's path must represent
+	// the fully qualified name of the type (as in
+	// `path/google.protobuf.Duration`). The name should be in a canonical form
+	// (e.g., leading "." is not accepted).
+	//
+	// In practice, teams usually precompile into the binary all types that they
+	// expect it to use in the context of Any. However, for URLs which use the
+	// scheme `http`, `https`, or no scheme, one can optionally set up a type
+	// server that maps type URLs to message definitions as follows:
+	//
+	// * If no scheme is provided, `https` is assumed.
+	// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+	//   value in binary format, or produce an error.
+	// * Applications are allowed to cache lookup results based on the
+	//   URL, or have them precompiled into a binary to avoid any
+	//   lookup. Therefore, binary compatibility needs to be preserved
+	//   on changes to types. (Use versioned type names to manage
+	//   breaking changes.)
+	//
+	// Note: this functionality is not currently available in the official
+	// protobuf release, and it is not used for type URLs beginning with
+	// type.googleapis.com.
+	//
+	// Schemes other than `http`, `https` (or the empty scheme) might be
+	// used with implementation specific semantics.
+	//
+	TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"`
+	// Must be a valid serialized protocol buffer of the above specified type.
+	Value                []byte   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-var file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
+func (m *Any) Reset()         { *m = Any{} }
+func (m *Any) String() string { return proto.CompactTextString(m) }
+func (*Any) ProtoMessage()    {}
+func (*Any) Descriptor() ([]byte, []int) {
+	return fileDescriptor_b53526c13ae22eb4, []int{0}
 }
 
-func init() { file_github_com_golang_protobuf_ptypes_any_any_proto_init() }
-func file_github_com_golang_protobuf_ptypes_any_any_proto_init() {
-	if File_github_com_golang_protobuf_ptypes_any_any_proto != nil {
-		return
+func (*Any) XXX_WellKnownType() string { return "Any" }
+
+func (m *Any) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Any.Unmarshal(m, b)
+}
+func (m *Any) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Any.Marshal(b, m, deterministic)
+}
+func (m *Any) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Any.Merge(m, src)
+}
+func (m *Any) XXX_Size() int {
+	return xxx_messageInfo_Any.Size(m)
+}
+func (m *Any) XXX_DiscardUnknown() {
+	xxx_messageInfo_Any.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Any proto.InternalMessageInfo
+
+func (m *Any) GetTypeUrl() string {
+	if m != nil {
+		return m.TypeUrl
 	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   0,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes,
-		DependencyIndexes: file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs,
-	}.Build()
-	File_github_com_golang_protobuf_ptypes_any_any_proto = out.File
-	file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc = nil
-	file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = nil
-	file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs = nil
+	return ""
+}
+
+func (m *Any) GetValue() []byte {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*Any)(nil), "google.protobuf.Any")
+}
+
+func init() { proto.RegisterFile("google/protobuf/any.proto", fileDescriptor_b53526c13ae22eb4) }
+
+var fileDescriptor_b53526c13ae22eb4 = []byte{
+	// 185 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xcf, 0xcf, 0x4f,
+	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcc, 0xab, 0xd4,
+	0x03, 0x73, 0x84, 0xf8, 0x21, 0x52, 0x7a, 0x30, 0x29, 0x25, 0x33, 0x2e, 0x66, 0xc7, 0xbc, 0x4a,
+	0x21, 0x49, 0x2e, 0x8e, 0x92, 0xca, 0x82, 0xd4, 0xf8, 0xd2, 0xa2, 0x1c, 0x09, 0x46, 0x05, 0x46,
+	0x0d, 0xce, 0x20, 0x76, 0x10, 0x3f, 0xb4, 0x28, 0x47, 0x48, 0x84, 0x8b, 0xb5, 0x2c, 0x31, 0xa7,
+	0x34, 0x55, 0x82, 0x49, 0x81, 0x51, 0x83, 0x27, 0x08, 0xc2, 0x71, 0xca, 0xe7, 0x12, 0x4e, 0xce,
+	0xcf, 0xd5, 0x43, 0x33, 0xce, 0x89, 0xc3, 0x31, 0xaf, 0x32, 0x00, 0xc4, 0x09, 0x60, 0x8c, 0x52,
+	0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc,
+	0x4b, 0x47, 0xb8, 0xa8, 0x00, 0x64, 0x7a, 0x31, 0xc8, 0x61, 0x8b, 0x98, 0x98, 0xdd, 0x03, 0x9c,
+	0x56, 0x31, 0xc9, 0xb9, 0x43, 0x8c, 0x0a, 0x80, 0x2a, 0xd1, 0x0b, 0x4f, 0xcd, 0xc9, 0xf1, 0xce,
+	0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0x29, 0x4d, 0x62, 0x03, 0xeb, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff,
+	0xff, 0x13, 0xf8, 0xe8, 0x42, 0xdd, 0x00, 0x00, 0x00,
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.proto b/vendor/github.com/golang/protobuf/ptypes/any/any.proto
new file mode 100644
index 0000000..4932942
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.proto
@@ -0,0 +1,154 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option go_package = "github.com/golang/protobuf/ptypes/any";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "AnyProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// `Any` contains an arbitrary serialized protocol buffer message along with a
+// URL that describes the type of the serialized message.
+//
+// Protobuf library provides support to pack/unpack Any values in the form
+// of utility functions or additional generated methods of the Any type.
+//
+// Example 1: Pack and unpack a message in C++.
+//
+//     Foo foo = ...;
+//     Any any;
+//     any.PackFrom(foo);
+//     ...
+//     if (any.UnpackTo(&foo)) {
+//       ...
+//     }
+//
+// Example 2: Pack and unpack a message in Java.
+//
+//     Foo foo = ...;
+//     Any any = Any.pack(foo);
+//     ...
+//     if (any.is(Foo.class)) {
+//       foo = any.unpack(Foo.class);
+//     }
+//
+//  Example 3: Pack and unpack a message in Python.
+//
+//     foo = Foo(...)
+//     any = Any()
+//     any.Pack(foo)
+//     ...
+//     if any.Is(Foo.DESCRIPTOR):
+//       any.Unpack(foo)
+//       ...
+//
+//  Example 4: Pack and unpack a message in Go
+//
+//      foo := &pb.Foo{...}
+//      any, err := ptypes.MarshalAny(foo)
+//      ...
+//      foo := &pb.Foo{}
+//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+//        ...
+//      }
+//
+// The pack methods provided by protobuf library will by default use
+// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+// methods only use the fully qualified type name after the last '/'
+// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+// name "y.z".
+//
+//
+// JSON
+// ====
+// The JSON representation of an `Any` value uses the regular
+// representation of the deserialized, embedded message, with an
+// additional field `@type` which contains the type URL. Example:
+//
+//     package google.profile;
+//     message Person {
+//       string first_name = 1;
+//       string last_name = 2;
+//     }
+//
+//     {
+//       "@type": "type.googleapis.com/google.profile.Person",
+//       "firstName": <string>,
+//       "lastName": <string>
+//     }
+//
+// If the embedded message type is well-known and has a custom JSON
+// representation, that representation will be embedded adding a field
+// `value` which holds the custom JSON in addition to the `@type`
+// field. Example (for message [google.protobuf.Duration][]):
+//
+//     {
+//       "@type": "type.googleapis.com/google.protobuf.Duration",
+//       "value": "1.212s"
+//     }
+//
+message Any {
+  // A URL/resource name that uniquely identifies the type of the serialized
+  // protocol buffer message. The last segment of the URL's path must represent
+  // the fully qualified name of the type (as in
+  // `path/google.protobuf.Duration`). The name should be in a canonical form
+  // (e.g., leading "." is not accepted).
+  //
+  // In practice, teams usually precompile into the binary all types that they
+  // expect it to use in the context of Any. However, for URLs which use the
+  // scheme `http`, `https`, or no scheme, one can optionally set up a type
+  // server that maps type URLs to message definitions as follows:
+  //
+  // * If no scheme is provided, `https` is assumed.
+  // * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+  //   value in binary format, or produce an error.
+  // * Applications are allowed to cache lookup results based on the
+  //   URL, or have them precompiled into a binary to avoid any
+  //   lookup. Therefore, binary compatibility needs to be preserved
+  //   on changes to types. (Use versioned type names to manage
+  //   breaking changes.)
+  //
+  // Note: this functionality is not currently available in the official
+  // protobuf release, and it is not used for type URLs beginning with
+  // type.googleapis.com.
+  //
+  // Schemes other than `http`, `https` (or the empty scheme) might be
+  // used with implementation specific semantics.
+  //
+  string type_url = 1;
+
+  // Must be a valid serialized protocol buffer of the above specified type.
+  bytes value = 2;
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/doc.go b/vendor/github.com/golang/protobuf/ptypes/doc.go
index fb9edd5..c0d595d 100644
--- a/vendor/github.com/golang/protobuf/ptypes/doc.go
+++ b/vendor/github.com/golang/protobuf/ptypes/doc.go
@@ -1,6 +1,35 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Package ptypes provides functionality for interacting with well-known types.
+/*
+Package ptypes contains code for interacting with well-known types.
+*/
 package ptypes
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration.go b/vendor/github.com/golang/protobuf/ptypes/duration.go
index 6110ae8..26d1ca2 100644
--- a/vendor/github.com/golang/protobuf/ptypes/duration.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration.go
@@ -1,72 +1,102 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 package ptypes
 
+// This file implements conversions between google.protobuf.Duration
+// and time.Duration.
+
 import (
 	"errors"
 	"fmt"
 	"time"
 
-	durationpb "github.com/golang/protobuf/ptypes/duration"
+	durpb "github.com/golang/protobuf/ptypes/duration"
 )
 
-// Range of google.protobuf.Duration as specified in duration.proto.
-// This is about 10,000 years in seconds.
 const (
+	// Range of a durpb.Duration in seconds, as specified in
+	// google/protobuf/duration.proto. This is about 10,000 years in seconds.
 	maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60)
 	minSeconds = -maxSeconds
 )
 
-// Duration converts a durationpb.Duration to a time.Duration.
-// Duration returns an error if dur is invalid or overflows a time.Duration.
-func Duration(dur *durationpb.Duration) (time.Duration, error) {
-	if err := validateDuration(dur); err != nil {
+// validateDuration determines whether the durpb.Duration is valid according to the
+// definition in google/protobuf/duration.proto. A valid durpb.Duration
+// may still be too large to fit into a time.Duration (the range of durpb.Duration
+// is about 10,000 years, and the range of time.Duration is about 290).
+func validateDuration(d *durpb.Duration) error {
+	if d == nil {
+		return errors.New("duration: nil Duration")
+	}
+	if d.Seconds < minSeconds || d.Seconds > maxSeconds {
+		return fmt.Errorf("duration: %v: seconds out of range", d)
+	}
+	if d.Nanos <= -1e9 || d.Nanos >= 1e9 {
+		return fmt.Errorf("duration: %v: nanos out of range", d)
+	}
+	// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
+	if (d.Seconds < 0 && d.Nanos > 0) || (d.Seconds > 0 && d.Nanos < 0) {
+		return fmt.Errorf("duration: %v: seconds and nanos have different signs", d)
+	}
+	return nil
+}
+
+// Duration converts a durpb.Duration to a time.Duration. Duration
+// returns an error if the durpb.Duration is invalid or is too large to be
+// represented in a time.Duration.
+func Duration(p *durpb.Duration) (time.Duration, error) {
+	if err := validateDuration(p); err != nil {
 		return 0, err
 	}
-	d := time.Duration(dur.Seconds) * time.Second
-	if int64(d/time.Second) != dur.Seconds {
-		return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur)
+	d := time.Duration(p.Seconds) * time.Second
+	if int64(d/time.Second) != p.Seconds {
+		return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
 	}
-	if dur.Nanos != 0 {
-		d += time.Duration(dur.Nanos) * time.Nanosecond
-		if (d < 0) != (dur.Nanos < 0) {
-			return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur)
+	if p.Nanos != 0 {
+		d += time.Duration(p.Nanos) * time.Nanosecond
+		if (d < 0) != (p.Nanos < 0) {
+			return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
 		}
 	}
 	return d, nil
 }
 
-// DurationProto converts a time.Duration to a durationpb.Duration.
-func DurationProto(d time.Duration) *durationpb.Duration {
+// DurationProto converts a time.Duration to a durpb.Duration.
+func DurationProto(d time.Duration) *durpb.Duration {
 	nanos := d.Nanoseconds()
 	secs := nanos / 1e9
 	nanos -= secs * 1e9
-	return &durationpb.Duration{
-		Seconds: int64(secs),
+	return &durpb.Duration{
+		Seconds: secs,
 		Nanos:   int32(nanos),
 	}
 }
-
-// validateDuration determines whether the durationpb.Duration is valid
-// according to the definition in google/protobuf/duration.proto.
-// A valid durpb.Duration may still be too large to fit into a time.Duration
-// Note that the range of durationpb.Duration is about 10,000 years,
-// while the range of time.Duration is about 290 years.
-func validateDuration(dur *durationpb.Duration) error {
-	if dur == nil {
-		return errors.New("duration: nil Duration")
-	}
-	if dur.Seconds < minSeconds || dur.Seconds > maxSeconds {
-		return fmt.Errorf("duration: %v: seconds out of range", dur)
-	}
-	if dur.Nanos <= -1e9 || dur.Nanos >= 1e9 {
-		return fmt.Errorf("duration: %v: nanos out of range", dur)
-	}
-	// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
-	if (dur.Seconds < 0 && dur.Nanos > 0) || (dur.Seconds > 0 && dur.Nanos < 0) {
-		return fmt.Errorf("duration: %v: seconds and nanos have different signs", dur)
-	}
-	return nil
-}
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
index d0079ee..0d681ee 100644
--- a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
@@ -1,63 +1,161 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/ptypes/duration/duration.proto
+// source: google/protobuf/duration.proto
 
 package duration
 
 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	durationpb "google.golang.org/protobuf/types/known/durationpb"
-	reflect "reflect"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
 )
 
-// Symbols defined in public import of google/protobuf/duration.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
 
-type Duration = durationpb.Duration
+// 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.ProtoPackageIsVersion3 // please upgrade the proto package
 
-var File_github_com_golang_protobuf_ptypes_duration_duration_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc = []byte{
-	0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
-	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
-	0x70, 0x65, 0x73, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x64, 0x75, 0x72,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x35, 0x5a, 0x33, 0x67,
-	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
-	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73,
-	0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+// A Duration represents a signed, fixed-length span of time represented
+// as a count of seconds and fractions of seconds at nanosecond
+// resolution. It is independent of any calendar and concepts like "day"
+// or "month". It is related to Timestamp in that the difference between
+// two Timestamp values is a Duration and it can be added or subtracted
+// from a Timestamp. Range is approximately +-10,000 years.
+//
+// # Examples
+//
+// Example 1: Compute Duration from two Timestamps in pseudo code.
+//
+//     Timestamp start = ...;
+//     Timestamp end = ...;
+//     Duration duration = ...;
+//
+//     duration.seconds = end.seconds - start.seconds;
+//     duration.nanos = end.nanos - start.nanos;
+//
+//     if (duration.seconds < 0 && duration.nanos > 0) {
+//       duration.seconds += 1;
+//       duration.nanos -= 1000000000;
+//     } else if (durations.seconds > 0 && duration.nanos < 0) {
+//       duration.seconds -= 1;
+//       duration.nanos += 1000000000;
+//     }
+//
+// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+//
+//     Timestamp start = ...;
+//     Duration duration = ...;
+//     Timestamp end = ...;
+//
+//     end.seconds = start.seconds + duration.seconds;
+//     end.nanos = start.nanos + duration.nanos;
+//
+//     if (end.nanos < 0) {
+//       end.seconds -= 1;
+//       end.nanos += 1000000000;
+//     } else if (end.nanos >= 1000000000) {
+//       end.seconds += 1;
+//       end.nanos -= 1000000000;
+//     }
+//
+// Example 3: Compute Duration from datetime.timedelta in Python.
+//
+//     td = datetime.timedelta(days=3, minutes=10)
+//     duration = Duration()
+//     duration.FromTimedelta(td)
+//
+// # JSON Mapping
+//
+// In JSON format, the Duration type is encoded as a string rather than an
+// object, where the string ends in the suffix "s" (indicating seconds) and
+// is preceded by the number of seconds, with nanoseconds expressed as
+// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+// microsecond should be expressed in JSON format as "3.000001s".
+//
+//
+type Duration struct {
+	// Signed seconds of the span of time. Must be from -315,576,000,000
+	// to +315,576,000,000 inclusive. Note: these bounds are computed from:
+	// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
+	// Signed fractions of a second at nanosecond resolution of the span
+	// of time. Durations less than one second are represented with a 0
+	// `seconds` field and a positive or negative `nanos` field. For durations
+	// of one second or more, a non-zero value for the `nanos` field must be
+	// of the same sign as the `seconds` field. Must be from -999,999,999
+	// to +999,999,999 inclusive.
+	Nanos                int32    `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-var file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
+func (m *Duration) Reset()         { *m = Duration{} }
+func (m *Duration) String() string { return proto.CompactTextString(m) }
+func (*Duration) ProtoMessage()    {}
+func (*Duration) Descriptor() ([]byte, []int) {
+	return fileDescriptor_23597b2ebd7ac6c5, []int{0}
 }
 
-func init() { file_github_com_golang_protobuf_ptypes_duration_duration_proto_init() }
-func file_github_com_golang_protobuf_ptypes_duration_duration_proto_init() {
-	if File_github_com_golang_protobuf_ptypes_duration_duration_proto != nil {
-		return
+func (*Duration) XXX_WellKnownType() string { return "Duration" }
+
+func (m *Duration) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Duration.Unmarshal(m, b)
+}
+func (m *Duration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Duration.Marshal(b, m, deterministic)
+}
+func (m *Duration) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Duration.Merge(m, src)
+}
+func (m *Duration) XXX_Size() int {
+	return xxx_messageInfo_Duration.Size(m)
+}
+func (m *Duration) XXX_DiscardUnknown() {
+	xxx_messageInfo_Duration.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Duration proto.InternalMessageInfo
+
+func (m *Duration) GetSeconds() int64 {
+	if m != nil {
+		return m.Seconds
 	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   0,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes,
-		DependencyIndexes: file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs,
-	}.Build()
-	File_github_com_golang_protobuf_ptypes_duration_duration_proto = out.File
-	file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc = nil
-	file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = nil
-	file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs = nil
+	return 0
+}
+
+func (m *Duration) GetNanos() int32 {
+	if m != nil {
+		return m.Nanos
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*Duration)(nil), "google.protobuf.Duration")
+}
+
+func init() { proto.RegisterFile("google/protobuf/duration.proto", fileDescriptor_23597b2ebd7ac6c5) }
+
+var fileDescriptor_23597b2ebd7ac6c5 = []byte{
+	// 190 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
+	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0x29, 0x2d, 0x4a,
+	0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0x56,
+	0x5c, 0x1c, 0x2e, 0x50, 0x25, 0x42, 0x12, 0x5c, 0xec, 0xc5, 0xa9, 0xc9, 0xf9, 0x79, 0x29, 0xc5,
+	0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xcc, 0x41, 0x30, 0xae, 0x90, 0x08, 0x17, 0x6b, 0x5e, 0x62, 0x5e,
+	0x7e, 0xb1, 0x04, 0x93, 0x02, 0xa3, 0x06, 0x6b, 0x10, 0x84, 0xe3, 0x54, 0xc3, 0x25, 0x9c, 0x9c,
+	0x9f, 0xab, 0x87, 0x66, 0xa4, 0x13, 0x2f, 0xcc, 0xc0, 0x00, 0x90, 0x48, 0x00, 0x63, 0x94, 0x56,
+	0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x7a, 0x7e, 0x4e, 0x62, 0x5e,
+	0x3a, 0xc2, 0x7d, 0x05, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x70, 0x67, 0xfe, 0x60, 0x64, 0x5c, 0xc4,
+	0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e, 0x00, 0x54, 0xa9, 0x5e, 0x78,
+	0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b, 0x12, 0x1b, 0xd8, 0x0c, 0x63,
+	0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x84, 0x30, 0xff, 0xf3, 0x00, 0x00, 0x00,
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto b/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto
new file mode 100644
index 0000000..975fce4
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto
@@ -0,0 +1,117 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/duration";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "DurationProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// A Duration represents a signed, fixed-length span of time represented
+// as a count of seconds and fractions of seconds at nanosecond
+// resolution. It is independent of any calendar and concepts like "day"
+// or "month". It is related to Timestamp in that the difference between
+// two Timestamp values is a Duration and it can be added or subtracted
+// from a Timestamp. Range is approximately +-10,000 years.
+//
+// # Examples
+//
+// Example 1: Compute Duration from two Timestamps in pseudo code.
+//
+//     Timestamp start = ...;
+//     Timestamp end = ...;
+//     Duration duration = ...;
+//
+//     duration.seconds = end.seconds - start.seconds;
+//     duration.nanos = end.nanos - start.nanos;
+//
+//     if (duration.seconds < 0 && duration.nanos > 0) {
+//       duration.seconds += 1;
+//       duration.nanos -= 1000000000;
+//     } else if (durations.seconds > 0 && duration.nanos < 0) {
+//       duration.seconds -= 1;
+//       duration.nanos += 1000000000;
+//     }
+//
+// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+//
+//     Timestamp start = ...;
+//     Duration duration = ...;
+//     Timestamp end = ...;
+//
+//     end.seconds = start.seconds + duration.seconds;
+//     end.nanos = start.nanos + duration.nanos;
+//
+//     if (end.nanos < 0) {
+//       end.seconds -= 1;
+//       end.nanos += 1000000000;
+//     } else if (end.nanos >= 1000000000) {
+//       end.seconds += 1;
+//       end.nanos -= 1000000000;
+//     }
+//
+// Example 3: Compute Duration from datetime.timedelta in Python.
+//
+//     td = datetime.timedelta(days=3, minutes=10)
+//     duration = Duration()
+//     duration.FromTimedelta(td)
+//
+// # JSON Mapping
+//
+// In JSON format, the Duration type is encoded as a string rather than an
+// object, where the string ends in the suffix "s" (indicating seconds) and
+// is preceded by the number of seconds, with nanoseconds expressed as
+// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+// microsecond should be expressed in JSON format as "3.000001s".
+//
+//
+message Duration {
+
+  // Signed seconds of the span of time. Must be from -315,576,000,000
+  // to +315,576,000,000 inclusive. Note: these bounds are computed from:
+  // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+  int64 seconds = 1;
+
+  // Signed fractions of a second at nanosecond resolution of the span
+  // of time. Durations less than one second are represented with a 0
+  // `seconds` field and a positive or negative `nanos` field. For durations
+  // of one second or more, a non-zero value for the `nanos` field must be
+  // of the same sign as the `seconds` field. Must be from -999,999,999
+  // to +999,999,999 inclusive.
+  int32 nanos = 2;
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go b/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
index 16686a6..b4eb03e 100644
--- a/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go
@@ -1,62 +1,83 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/ptypes/empty/empty.proto
+// source: google/protobuf/empty.proto
 
 package empty
 
 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	emptypb "google.golang.org/protobuf/types/known/emptypb"
-	reflect "reflect"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
 )
 
-// Symbols defined in public import of google/protobuf/empty.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
 
-type Empty = emptypb.Empty
+// 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.ProtoPackageIsVersion3 // please upgrade the proto package
 
-var File_github_com_golang_protobuf_ptypes_empty_empty_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc = []byte{
-	0x0a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
-	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
-	0x70, 0x65, 0x73, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x42, 0x2f, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
-	0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x3b, 0x65, 0x6d,
-	0x70, 0x74, 0x79, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+// A generic empty message that you can re-use to avoid defining duplicated
+// empty messages in your APIs. A typical example is to use it as the request
+// or the response type of an API method. For instance:
+//
+//     service Foo {
+//       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+//     }
+//
+// The JSON representation for `Empty` is empty JSON object `{}`.
+type Empty struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-var file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
+func (m *Empty) Reset()         { *m = Empty{} }
+func (m *Empty) String() string { return proto.CompactTextString(m) }
+func (*Empty) ProtoMessage()    {}
+func (*Empty) Descriptor() ([]byte, []int) {
+	return fileDescriptor_900544acb223d5b8, []int{0}
 }
 
-func init() { file_github_com_golang_protobuf_ptypes_empty_empty_proto_init() }
-func file_github_com_golang_protobuf_ptypes_empty_empty_proto_init() {
-	if File_github_com_golang_protobuf_ptypes_empty_empty_proto != nil {
-		return
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   0,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes,
-		DependencyIndexes: file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs,
-	}.Build()
-	File_github_com_golang_protobuf_ptypes_empty_empty_proto = out.File
-	file_github_com_golang_protobuf_ptypes_empty_empty_proto_rawDesc = nil
-	file_github_com_golang_protobuf_ptypes_empty_empty_proto_goTypes = nil
-	file_github_com_golang_protobuf_ptypes_empty_empty_proto_depIdxs = nil
+func (*Empty) XXX_WellKnownType() string { return "Empty" }
+
+func (m *Empty) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Empty.Unmarshal(m, b)
+}
+func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
+}
+func (m *Empty) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Empty.Merge(m, src)
+}
+func (m *Empty) XXX_Size() int {
+	return xxx_messageInfo_Empty.Size(m)
+}
+func (m *Empty) XXX_DiscardUnknown() {
+	xxx_messageInfo_Empty.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Empty proto.InternalMessageInfo
+
+func init() {
+	proto.RegisterType((*Empty)(nil), "google.protobuf.Empty")
+}
+
+func init() { proto.RegisterFile("google/protobuf/empty.proto", fileDescriptor_900544acb223d5b8) }
+
+var fileDescriptor_900544acb223d5b8 = []byte{
+	// 148 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xcf, 0xcf, 0x4f,
+	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcd, 0x2d, 0x28,
+	0xa9, 0xd4, 0x03, 0x73, 0x85, 0xf8, 0x21, 0x92, 0x7a, 0x30, 0x49, 0x25, 0x76, 0x2e, 0x56, 0x57,
+	0x90, 0xbc, 0x53, 0x19, 0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x9a, 0xbc, 0x13, 0x17, 0x58, 0x36,
+	0x00, 0xc4, 0x0d, 0x60, 0x8c, 0x52, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
+	0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0x47, 0x58, 0x53, 0x50, 0x52, 0x59, 0x90, 0x5a, 0x0c,
+	0xb1, 0xed, 0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10,
+	0x13, 0x03, 0xa0, 0xea, 0xf4, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40,
+	0xea, 0x93, 0xd8, 0xc0, 0x06, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x64, 0xd4, 0xb3, 0xa6,
+	0xb7, 0x00, 0x00, 0x00,
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto b/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto
new file mode 100644
index 0000000..03cacd2
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/empty/empty.proto
@@ -0,0 +1,52 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option go_package = "github.com/golang/protobuf/ptypes/empty";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "EmptyProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+option cc_enable_arenas = true;
+
+// A generic empty message that you can re-use to avoid defining duplicated
+// empty messages in your APIs. A typical example is to use it as the request
+// or the response type of an API method. For instance:
+//
+//     service Foo {
+//       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+//     }
+//
+// The JSON representation for `Empty` is empty JSON object `{}`.
+message Empty {}
diff --git a/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go b/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go
new file mode 100644
index 0000000..33daa73
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go
@@ -0,0 +1,336 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/struct.proto
+
+package structpb
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
+
+// 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.ProtoPackageIsVersion3 // please upgrade the proto package
+
+// `NullValue` is a singleton enumeration to represent the null value for the
+// `Value` type union.
+//
+//  The JSON representation for `NullValue` is JSON `null`.
+type NullValue int32
+
+const (
+	// Null value.
+	NullValue_NULL_VALUE NullValue = 0
+)
+
+var NullValue_name = map[int32]string{
+	0: "NULL_VALUE",
+}
+
+var NullValue_value = map[string]int32{
+	"NULL_VALUE": 0,
+}
+
+func (x NullValue) String() string {
+	return proto.EnumName(NullValue_name, int32(x))
+}
+
+func (NullValue) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_df322afd6c9fb402, []int{0}
+}
+
+func (NullValue) XXX_WellKnownType() string { return "NullValue" }
+
+// `Struct` represents a structured data value, consisting of fields
+// which map to dynamically typed values. In some languages, `Struct`
+// might be supported by a native representation. For example, in
+// scripting languages like JS a struct is represented as an
+// object. The details of that representation are described together
+// with the proto support for the language.
+//
+// The JSON representation for `Struct` is JSON object.
+type Struct struct {
+	// Unordered map of dynamically typed values.
+	Fields               map[string]*Value `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *Struct) Reset()         { *m = Struct{} }
+func (m *Struct) String() string { return proto.CompactTextString(m) }
+func (*Struct) ProtoMessage()    {}
+func (*Struct) Descriptor() ([]byte, []int) {
+	return fileDescriptor_df322afd6c9fb402, []int{0}
+}
+
+func (*Struct) XXX_WellKnownType() string { return "Struct" }
+
+func (m *Struct) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Struct.Unmarshal(m, b)
+}
+func (m *Struct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Struct.Marshal(b, m, deterministic)
+}
+func (m *Struct) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Struct.Merge(m, src)
+}
+func (m *Struct) XXX_Size() int {
+	return xxx_messageInfo_Struct.Size(m)
+}
+func (m *Struct) XXX_DiscardUnknown() {
+	xxx_messageInfo_Struct.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Struct proto.InternalMessageInfo
+
+func (m *Struct) GetFields() map[string]*Value {
+	if m != nil {
+		return m.Fields
+	}
+	return nil
+}
+
+// `Value` represents a dynamically typed value which can be either
+// null, a number, a string, a boolean, a recursive struct value, or a
+// list of values. A producer of value is expected to set one of that
+// variants, absence of any variant indicates an error.
+//
+// The JSON representation for `Value` is JSON value.
+type Value struct {
+	// The kind of value.
+	//
+	// Types that are valid to be assigned to Kind:
+	//	*Value_NullValue
+	//	*Value_NumberValue
+	//	*Value_StringValue
+	//	*Value_BoolValue
+	//	*Value_StructValue
+	//	*Value_ListValue
+	Kind                 isValue_Kind `protobuf_oneof:"kind"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *Value) Reset()         { *m = Value{} }
+func (m *Value) String() string { return proto.CompactTextString(m) }
+func (*Value) ProtoMessage()    {}
+func (*Value) Descriptor() ([]byte, []int) {
+	return fileDescriptor_df322afd6c9fb402, []int{1}
+}
+
+func (*Value) XXX_WellKnownType() string { return "Value" }
+
+func (m *Value) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Value.Unmarshal(m, b)
+}
+func (m *Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Value.Marshal(b, m, deterministic)
+}
+func (m *Value) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Value.Merge(m, src)
+}
+func (m *Value) XXX_Size() int {
+	return xxx_messageInfo_Value.Size(m)
+}
+func (m *Value) XXX_DiscardUnknown() {
+	xxx_messageInfo_Value.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Value proto.InternalMessageInfo
+
+type isValue_Kind interface {
+	isValue_Kind()
+}
+
+type Value_NullValue struct {
+	NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,proto3,enum=google.protobuf.NullValue,oneof"`
+}
+
+type Value_NumberValue struct {
+	NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,proto3,oneof"`
+}
+
+type Value_StringValue struct {
+	StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"`
+}
+
+type Value_BoolValue struct {
+	BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,proto3,oneof"`
+}
+
+type Value_StructValue struct {
+	StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,proto3,oneof"`
+}
+
+type Value_ListValue struct {
+	ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,proto3,oneof"`
+}
+
+func (*Value_NullValue) isValue_Kind() {}
+
+func (*Value_NumberValue) isValue_Kind() {}
+
+func (*Value_StringValue) isValue_Kind() {}
+
+func (*Value_BoolValue) isValue_Kind() {}
+
+func (*Value_StructValue) isValue_Kind() {}
+
+func (*Value_ListValue) isValue_Kind() {}
+
+func (m *Value) GetKind() isValue_Kind {
+	if m != nil {
+		return m.Kind
+	}
+	return nil
+}
+
+func (m *Value) GetNullValue() NullValue {
+	if x, ok := m.GetKind().(*Value_NullValue); ok {
+		return x.NullValue
+	}
+	return NullValue_NULL_VALUE
+}
+
+func (m *Value) GetNumberValue() float64 {
+	if x, ok := m.GetKind().(*Value_NumberValue); ok {
+		return x.NumberValue
+	}
+	return 0
+}
+
+func (m *Value) GetStringValue() string {
+	if x, ok := m.GetKind().(*Value_StringValue); ok {
+		return x.StringValue
+	}
+	return ""
+}
+
+func (m *Value) GetBoolValue() bool {
+	if x, ok := m.GetKind().(*Value_BoolValue); ok {
+		return x.BoolValue
+	}
+	return false
+}
+
+func (m *Value) GetStructValue() *Struct {
+	if x, ok := m.GetKind().(*Value_StructValue); ok {
+		return x.StructValue
+	}
+	return nil
+}
+
+func (m *Value) GetListValue() *ListValue {
+	if x, ok := m.GetKind().(*Value_ListValue); ok {
+		return x.ListValue
+	}
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Value) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*Value_NullValue)(nil),
+		(*Value_NumberValue)(nil),
+		(*Value_StringValue)(nil),
+		(*Value_BoolValue)(nil),
+		(*Value_StructValue)(nil),
+		(*Value_ListValue)(nil),
+	}
+}
+
+// `ListValue` is a wrapper around a repeated field of values.
+//
+// The JSON representation for `ListValue` is JSON array.
+type ListValue struct {
+	// Repeated field of dynamically typed values.
+	Values               []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ListValue) Reset()         { *m = ListValue{} }
+func (m *ListValue) String() string { return proto.CompactTextString(m) }
+func (*ListValue) ProtoMessage()    {}
+func (*ListValue) Descriptor() ([]byte, []int) {
+	return fileDescriptor_df322afd6c9fb402, []int{2}
+}
+
+func (*ListValue) XXX_WellKnownType() string { return "ListValue" }
+
+func (m *ListValue) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ListValue.Unmarshal(m, b)
+}
+func (m *ListValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ListValue.Marshal(b, m, deterministic)
+}
+func (m *ListValue) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListValue.Merge(m, src)
+}
+func (m *ListValue) XXX_Size() int {
+	return xxx_messageInfo_ListValue.Size(m)
+}
+func (m *ListValue) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListValue proto.InternalMessageInfo
+
+func (m *ListValue) GetValues() []*Value {
+	if m != nil {
+		return m.Values
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterEnum("google.protobuf.NullValue", NullValue_name, NullValue_value)
+	proto.RegisterType((*Struct)(nil), "google.protobuf.Struct")
+	proto.RegisterMapType((map[string]*Value)(nil), "google.protobuf.Struct.FieldsEntry")
+	proto.RegisterType((*Value)(nil), "google.protobuf.Value")
+	proto.RegisterType((*ListValue)(nil), "google.protobuf.ListValue")
+}
+
+func init() { proto.RegisterFile("google/protobuf/struct.proto", fileDescriptor_df322afd6c9fb402) }
+
+var fileDescriptor_df322afd6c9fb402 = []byte{
+	// 417 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0x41, 0x8b, 0xd3, 0x40,
+	0x14, 0xc7, 0x3b, 0xc9, 0x36, 0x98, 0x17, 0x59, 0x97, 0x11, 0xb4, 0xac, 0xa2, 0xa1, 0x7b, 0x09,
+	0x22, 0x29, 0xd6, 0x8b, 0x18, 0x2f, 0x06, 0xd6, 0x5d, 0x30, 0x2c, 0x31, 0xba, 0x15, 0xbc, 0x94,
+	0x26, 0x4d, 0x63, 0xe8, 0x74, 0x26, 0x24, 0x33, 0x4a, 0x8f, 0x7e, 0x0b, 0xcf, 0x1e, 0x3d, 0xfa,
+	0xe9, 0x3c, 0xca, 0xcc, 0x24, 0xa9, 0xb4, 0xf4, 0x94, 0xbc, 0xf7, 0x7e, 0xef, 0x3f, 0xef, 0xff,
+	0x66, 0xe0, 0x71, 0xc1, 0x58, 0x41, 0xf2, 0x49, 0x55, 0x33, 0xce, 0x52, 0xb1, 0x9a, 0x34, 0xbc,
+	0x16, 0x19, 0xf7, 0x55, 0x8c, 0xef, 0xe9, 0xaa, 0xdf, 0x55, 0xc7, 0x3f, 0x11, 0x58, 0x1f, 0x15,
+	0x81, 0x03, 0xb0, 0x56, 0x65, 0x4e, 0x96, 0xcd, 0x08, 0xb9, 0xa6, 0xe7, 0x4c, 0x2f, 0xfc, 0x3d,
+	0xd8, 0xd7, 0xa0, 0xff, 0x4e, 0x51, 0x97, 0x94, 0xd7, 0xdb, 0xa4, 0x6d, 0x39, 0xff, 0x00, 0xce,
+	0x7f, 0x69, 0x7c, 0x06, 0xe6, 0x3a, 0xdf, 0x8e, 0x90, 0x8b, 0x3c, 0x3b, 0x91, 0xbf, 0xf8, 0x39,
+	0x0c, 0xbf, 0x2d, 0x88, 0xc8, 0x47, 0x86, 0x8b, 0x3c, 0x67, 0xfa, 0xe0, 0x40, 0x7c, 0x26, 0xab,
+	0x89, 0x86, 0x5e, 0x1b, 0xaf, 0xd0, 0xf8, 0x8f, 0x01, 0x43, 0x95, 0xc4, 0x01, 0x00, 0x15, 0x84,
+	0xcc, 0xb5, 0x80, 0x14, 0x3d, 0x9d, 0x9e, 0x1f, 0x08, 0xdc, 0x08, 0x42, 0x14, 0x7f, 0x3d, 0x48,
+	0x6c, 0xda, 0x05, 0xf8, 0x02, 0xee, 0x52, 0xb1, 0x49, 0xf3, 0x7a, 0xbe, 0x3b, 0x1f, 0x5d, 0x0f,
+	0x12, 0x47, 0x67, 0x7b, 0xa8, 0xe1, 0x75, 0x49, 0x8b, 0x16, 0x32, 0xe5, 0xe0, 0x12, 0xd2, 0x59,
+	0x0d, 0x3d, 0x05, 0x48, 0x19, 0xeb, 0xc6, 0x38, 0x71, 0x91, 0x77, 0x47, 0x1e, 0x25, 0x73, 0x1a,
+	0x78, 0xa3, 0x54, 0x44, 0xc6, 0x5b, 0x64, 0xa8, 0xac, 0x3e, 0x3c, 0xb2, 0xc7, 0x56, 0x5e, 0x64,
+	0xbc, 0x77, 0x49, 0xca, 0xa6, 0xeb, 0xb5, 0x54, 0xef, 0xa1, 0xcb, 0xa8, 0x6c, 0x78, 0xef, 0x92,
+	0x74, 0x41, 0x68, 0xc1, 0xc9, 0xba, 0xa4, 0xcb, 0x71, 0x00, 0x76, 0x4f, 0x60, 0x1f, 0x2c, 0x25,
+	0xd6, 0xdd, 0xe8, 0xb1, 0xa5, 0xb7, 0xd4, 0xb3, 0x47, 0x60, 0xf7, 0x4b, 0xc4, 0xa7, 0x00, 0x37,
+	0xb7, 0x51, 0x34, 0x9f, 0xbd, 0x8d, 0x6e, 0x2f, 0xcf, 0x06, 0xe1, 0x0f, 0x04, 0xf7, 0x33, 0xb6,
+	0xd9, 0x97, 0x08, 0x1d, 0xed, 0x26, 0x96, 0x71, 0x8c, 0xbe, 0xbc, 0x28, 0x4a, 0xfe, 0x55, 0xa4,
+	0x7e, 0xc6, 0x36, 0x93, 0x82, 0x91, 0x05, 0x2d, 0x76, 0x4f, 0xb1, 0xe2, 0xdb, 0x2a, 0x6f, 0xda,
+	0x17, 0x19, 0xe8, 0x4f, 0x95, 0xfe, 0x45, 0xe8, 0x97, 0x61, 0x5e, 0xc5, 0xe1, 0x6f, 0xe3, 0xc9,
+	0x95, 0x16, 0x8f, 0xbb, 0xf9, 0x3e, 0xe7, 0x84, 0xbc, 0xa7, 0xec, 0x3b, 0xfd, 0x24, 0x3b, 0x53,
+	0x4b, 0x49, 0xbd, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xe8, 0x1b, 0x59, 0xf8, 0xe5, 0x02, 0x00,
+	0x00,
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/struct/struct.proto b/vendor/github.com/golang/protobuf/ptypes/struct/struct.proto
new file mode 100644
index 0000000..7d7808e
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/struct/struct.proto
@@ -0,0 +1,96 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/struct;structpb";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "StructProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+
+// `Struct` represents a structured data value, consisting of fields
+// which map to dynamically typed values. In some languages, `Struct`
+// might be supported by a native representation. For example, in
+// scripting languages like JS a struct is represented as an
+// object. The details of that representation are described together
+// with the proto support for the language.
+//
+// The JSON representation for `Struct` is JSON object.
+message Struct {
+  // Unordered map of dynamically typed values.
+  map<string, Value> fields = 1;
+}
+
+// `Value` represents a dynamically typed value which can be either
+// null, a number, a string, a boolean, a recursive struct value, or a
+// list of values. A producer of value is expected to set one of that
+// variants, absence of any variant indicates an error.
+//
+// The JSON representation for `Value` is JSON value.
+message Value {
+  // The kind of value.
+  oneof kind {
+    // Represents a null value.
+    NullValue null_value = 1;
+    // Represents a double value.
+    double number_value = 2;
+    // Represents a string value.
+    string string_value = 3;
+    // Represents a boolean value.
+    bool bool_value = 4;
+    // Represents a structured value.
+    Struct struct_value = 5;
+    // Represents a repeated `Value`.
+    ListValue list_value = 6;
+  }
+}
+
+// `NullValue` is a singleton enumeration to represent the null value for the
+// `Value` type union.
+//
+//  The JSON representation for `NullValue` is JSON `null`.
+enum NullValue {
+  // Null value.
+  NULL_VALUE = 0;
+}
+
+// `ListValue` is a wrapper around a repeated field of values.
+//
+// The JSON representation for `ListValue` is JSON array.
+message ListValue {
+  // Repeated field of dynamically typed values.
+  repeated Value values = 1;
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp.go b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
index 026d0d4..8da0df0 100644
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
@@ -1,18 +1,46 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 package ptypes
 
+// This file implements operations on google.protobuf.Timestamp.
+
 import (
 	"errors"
 	"fmt"
 	"time"
 
-	timestamppb "github.com/golang/protobuf/ptypes/timestamp"
+	tspb "github.com/golang/protobuf/ptypes/timestamp"
 )
 
-// Range of google.protobuf.Duration as specified in timestamp.proto.
 const (
 	// Seconds field of the earliest valid Timestamp.
 	// This is time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
@@ -22,71 +50,17 @@
 	maxValidSeconds = 253402300800
 )
 
-// Timestamp converts a timestamppb.Timestamp to a time.Time.
-// It returns an error if the argument is invalid.
-//
-// Unlike most Go functions, if Timestamp returns an error, the first return
-// value is not the zero time.Time. Instead, it is the value obtained from the
-// time.Unix function when passed the contents of the Timestamp, in the UTC
-// locale. This may or may not be a meaningful time; many invalid Timestamps
-// do map to valid time.Times.
-//
-// A nil Timestamp returns an error. The first return value in that case is
-// undefined.
-func Timestamp(ts *timestamppb.Timestamp) (time.Time, error) {
-	// Don't return the zero value on error, because corresponds to a valid
-	// timestamp. Instead return whatever time.Unix gives us.
-	var t time.Time
-	if ts == nil {
-		t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
-	} else {
-		t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC()
-	}
-	return t, validateTimestamp(ts)
-}
-
-// TimestampNow returns a google.protobuf.Timestamp for the current time.
-func TimestampNow() *timestamppb.Timestamp {
-	ts, err := TimestampProto(time.Now())
-	if err != nil {
-		panic("ptypes: time.Now() out of Timestamp range")
-	}
-	return ts
-}
-
-// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
-// It returns an error if the resulting Timestamp is invalid.
-func TimestampProto(t time.Time) (*timestamppb.Timestamp, error) {
-	ts := &timestamppb.Timestamp{
-		Seconds: t.Unix(),
-		Nanos:   int32(t.Nanosecond()),
-	}
-	if err := validateTimestamp(ts); err != nil {
-		return nil, err
-	}
-	return ts, nil
-}
-
-// TimestampString returns the RFC 3339 string for valid Timestamps.
-// For invalid Timestamps, it returns an error message in parentheses.
-func TimestampString(ts *timestamppb.Timestamp) string {
-	t, err := Timestamp(ts)
-	if err != nil {
-		return fmt.Sprintf("(%v)", err)
-	}
-	return t.Format(time.RFC3339Nano)
-}
-
 // validateTimestamp determines whether a Timestamp is valid.
-// A valid timestamp represents a time in the range [0001-01-01, 10000-01-01)
-// and has a Nanos field in the range [0, 1e9).
+// A valid timestamp represents a time in the range
+// [0001-01-01, 10000-01-01) and has a Nanos field
+// in the range [0, 1e9).
 //
 // If the Timestamp is valid, validateTimestamp returns nil.
-// Otherwise, it returns an error that describes the problem.
+// Otherwise, it returns an error that describes
+// the problem.
 //
-// Every valid Timestamp can be represented by a time.Time,
-// but the converse is not true.
-func validateTimestamp(ts *timestamppb.Timestamp) error {
+// Every valid Timestamp can be represented by a time.Time, but the converse is not true.
+func validateTimestamp(ts *tspb.Timestamp) error {
 	if ts == nil {
 		return errors.New("timestamp: nil Timestamp")
 	}
@@ -101,3 +75,58 @@
 	}
 	return nil
 }
+
+// Timestamp converts a google.protobuf.Timestamp proto to a time.Time.
+// It returns an error if the argument is invalid.
+//
+// Unlike most Go functions, if Timestamp returns an error, the first return value
+// is not the zero time.Time. Instead, it is the value obtained from the
+// time.Unix function when passed the contents of the Timestamp, in the UTC
+// locale. This may or may not be a meaningful time; many invalid Timestamps
+// do map to valid time.Times.
+//
+// A nil Timestamp returns an error. The first return value in that case is
+// undefined.
+func Timestamp(ts *tspb.Timestamp) (time.Time, error) {
+	// Don't return the zero value on error, because corresponds to a valid
+	// timestamp. Instead return whatever time.Unix gives us.
+	var t time.Time
+	if ts == nil {
+		t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
+	} else {
+		t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC()
+	}
+	return t, validateTimestamp(ts)
+}
+
+// TimestampNow returns a google.protobuf.Timestamp for the current time.
+func TimestampNow() *tspb.Timestamp {
+	ts, err := TimestampProto(time.Now())
+	if err != nil {
+		panic("ptypes: time.Now() out of Timestamp range")
+	}
+	return ts
+}
+
+// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
+// It returns an error if the resulting Timestamp is invalid.
+func TimestampProto(t time.Time) (*tspb.Timestamp, error) {
+	ts := &tspb.Timestamp{
+		Seconds: t.Unix(),
+		Nanos:   int32(t.Nanosecond()),
+	}
+	if err := validateTimestamp(ts); err != nil {
+		return nil, err
+	}
+	return ts, nil
+}
+
+// TimestampString returns the RFC 3339 string for valid Timestamps. For invalid
+// Timestamps, it returns an error message in parentheses.
+func TimestampString(ts *tspb.Timestamp) string {
+	t, err := Timestamp(ts)
+	if err != nil {
+		return fmt.Sprintf("(%v)", err)
+	}
+	return t.Format(time.RFC3339Nano)
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
index a76f807..31cd846 100644
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
@@ -1,64 +1,179 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+// source: google/protobuf/timestamp.proto
 
 package timestamp
 
 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
-	reflect "reflect"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
 )
 
-// Symbols defined in public import of google/protobuf/timestamp.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
 
-type Timestamp = timestamppb.Timestamp
+// 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.ProtoPackageIsVersion3 // please upgrade the proto package
 
-var File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = []byte{
-	0x0a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
-	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
-	0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2f, 0x74, 0x69,
-	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74,
-	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x37,
-	0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
-	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
-	0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x3b, 0x74, 0x69,
-	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x33,
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// # Examples
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     timestamp = Timestamp()
+//     timestamp.GetCurrentTime()
+//
+// # JSON Mapping
+//
+// In JSON format, the Timestamp type is encoded as a string in the
+// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+// where {year} is always expressed using four digits while {month}, {day},
+// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+// is required. A proto3 JSON serializer should always use UTC (as indicated by
+// "Z") when printing the Timestamp type and a proto3 JSON parser should be
+// able to accept both UTC and other timezones (as indicated by an offset).
+//
+// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+// 01:30 UTC on January 15, 2017.
+//
+// In JavaScript, one can convert a Date object to this format using the
+// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
+// method. In Python, a standard `datetime.datetime` object can be converted
+// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
+// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
+// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
+// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--
+// ) to obtain a formatter capable of generating timestamps in this format.
+//
+//
+type Timestamp struct {
+	// Represents seconds of UTC time since Unix epoch
+	// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+	// 9999-12-31T23:59:59Z inclusive.
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
+	// Non-negative fractions of a second at nanosecond resolution. Negative
+	// second values with fractions must still have non-negative nanos values
+	// that count forward in time. Must be from 0 to 999,999,999
+	// inclusive.
+	Nanos                int32    `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
+func (m *Timestamp) Reset()         { *m = Timestamp{} }
+func (m *Timestamp) String() string { return proto.CompactTextString(m) }
+func (*Timestamp) ProtoMessage()    {}
+func (*Timestamp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_292007bbfe81227e, []int{0}
 }
 
-func init() { file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() }
-func file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() {
-	if File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto != nil {
-		return
+func (*Timestamp) XXX_WellKnownType() string { return "Timestamp" }
+
+func (m *Timestamp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Timestamp.Unmarshal(m, b)
+}
+func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic)
+}
+func (m *Timestamp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Timestamp.Merge(m, src)
+}
+func (m *Timestamp) XXX_Size() int {
+	return xxx_messageInfo_Timestamp.Size(m)
+}
+func (m *Timestamp) XXX_DiscardUnknown() {
+	xxx_messageInfo_Timestamp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Timestamp proto.InternalMessageInfo
+
+func (m *Timestamp) GetSeconds() int64 {
+	if m != nil {
+		return m.Seconds
 	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   0,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes,
-		DependencyIndexes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs,
-	}.Build()
-	File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto = out.File
-	file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = nil
-	file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = nil
-	file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = nil
+	return 0
+}
+
+func (m *Timestamp) GetNanos() int32 {
+	if m != nil {
+		return m.Nanos
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
+}
+
+func init() { proto.RegisterFile("google/protobuf/timestamp.proto", fileDescriptor_292007bbfe81227e) }
+
+var fileDescriptor_292007bbfe81227e = []byte{
+	// 191 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xcf, 0xcf, 0x4f,
+	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d,
+	0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0xd0, 0x03, 0x0b, 0x09, 0xf1, 0x43, 0x14, 0xe8, 0xc1, 0x14, 0x28,
+	0x59, 0x73, 0x71, 0x86, 0xc0, 0xd4, 0x08, 0x49, 0x70, 0xb1, 0x17, 0xa7, 0x26, 0xe7, 0xe7, 0xa5,
+	0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x30, 0x07, 0xc1, 0xb8, 0x42, 0x22, 0x5c, 0xac, 0x79, 0x89,
+	0x79, 0xf9, 0xc5, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xac, 0x41, 0x10, 0x8e, 0x53, 0x1d, 0x97, 0x70,
+	0x72, 0x7e, 0xae, 0x1e, 0x9a, 0x99, 0x4e, 0x7c, 0x70, 0x13, 0x03, 0x40, 0x42, 0x01, 0x8c, 0x51,
+	0xda, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0xe9, 0xf9, 0x39, 0x89,
+	0x79, 0xe9, 0x08, 0x27, 0x16, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x23, 0x5c, 0xfa, 0x83, 0x91, 0x71,
+	0x11, 0x13, 0xb3, 0x7b, 0x80, 0xd3, 0x2a, 0x26, 0x39, 0x77, 0x88, 0xc9, 0x01, 0x50, 0xb5, 0x7a,
+	0xe1, 0xa9, 0x39, 0x39, 0xde, 0x79, 0xf9, 0xe5, 0x79, 0x21, 0x20, 0x3d, 0x49, 0x6c, 0x60, 0x43,
+	0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x77, 0x4a, 0x07, 0xf7, 0x00, 0x00, 0x00,
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
new file mode 100644
index 0000000..eafb3fa
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
@@ -0,0 +1,135 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/timestamp";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "TimestampProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// # Examples
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     timestamp = Timestamp()
+//     timestamp.GetCurrentTime()
+//
+// # JSON Mapping
+//
+// In JSON format, the Timestamp type is encoded as a string in the
+// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+// where {year} is always expressed using four digits while {month}, {day},
+// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+// is required. A proto3 JSON serializer should always use UTC (as indicated by
+// "Z") when printing the Timestamp type and a proto3 JSON parser should be
+// able to accept both UTC and other timezones (as indicated by an offset).
+//
+// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+// 01:30 UTC on January 15, 2017.
+//
+// In JavaScript, one can convert a Date object to this format using the
+// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
+// method. In Python, a standard `datetime.datetime` object can be converted
+// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
+// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
+// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
+// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--
+// ) to obtain a formatter capable of generating timestamps in this format.
+//
+//
+message Timestamp {
+
+  // Represents seconds of UTC time since Unix epoch
+  // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+  // 9999-12-31T23:59:59Z inclusive.
+  int64 seconds = 1;
+
+  // Non-negative fractions of a second at nanosecond resolution. Negative
+  // second values with fractions must still have non-negative nanos values
+  // that count forward in time. Must be from 0 to 999,999,999
+  // inclusive.
+  int32 nanos = 2;
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go
index cc40f27..add19a1 100644
--- a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go
@@ -1,71 +1,461 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: github.com/golang/protobuf/ptypes/wrappers/wrappers.proto
+// source: google/protobuf/wrappers.proto
 
 package wrappers
 
 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
-	reflect "reflect"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
 )
 
-// Symbols defined in public import of google/protobuf/wrappers.proto.
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
 
-type DoubleValue = wrapperspb.DoubleValue
-type FloatValue = wrapperspb.FloatValue
-type Int64Value = wrapperspb.Int64Value
-type UInt64Value = wrapperspb.UInt64Value
-type Int32Value = wrapperspb.Int32Value
-type UInt32Value = wrapperspb.UInt32Value
-type BoolValue = wrapperspb.BoolValue
-type StringValue = wrapperspb.StringValue
-type BytesValue = wrapperspb.BytesValue
+// 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.ProtoPackageIsVersion3 // please upgrade the proto package
 
-var File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto protoreflect.FileDescriptor
-
-var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc = []byte{
-	0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
-	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
-	0x70, 0x65, 0x73, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x2f, 0x77, 0x72, 0x61,
-	0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61,
-	0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x35, 0x5a, 0x33, 0x67,
-	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
-	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73,
-	0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x3b, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65,
-	0x72, 0x73, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+// Wrapper message for `double`.
+//
+// The JSON representation for `DoubleValue` is JSON number.
+type DoubleValue struct {
+	// The double value.
+	Value                float64  `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes = []interface{}{}
-var file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
+func (m *DoubleValue) Reset()         { *m = DoubleValue{} }
+func (m *DoubleValue) String() string { return proto.CompactTextString(m) }
+func (*DoubleValue) ProtoMessage()    {}
+func (*DoubleValue) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5377b62bda767935, []int{0}
 }
 
-func init() { file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_init() }
-func file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_init() {
-	if File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto != nil {
-		return
+func (*DoubleValue) XXX_WellKnownType() string { return "DoubleValue" }
+
+func (m *DoubleValue) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DoubleValue.Unmarshal(m, b)
+}
+func (m *DoubleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DoubleValue.Marshal(b, m, deterministic)
+}
+func (m *DoubleValue) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DoubleValue.Merge(m, src)
+}
+func (m *DoubleValue) XXX_Size() int {
+	return xxx_messageInfo_DoubleValue.Size(m)
+}
+func (m *DoubleValue) XXX_DiscardUnknown() {
+	xxx_messageInfo_DoubleValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DoubleValue proto.InternalMessageInfo
+
+func (m *DoubleValue) GetValue() float64 {
+	if m != nil {
+		return m.Value
 	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   0,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes,
-		DependencyIndexes: file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs,
-	}.Build()
-	File_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto = out.File
-	file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_rawDesc = nil
-	file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_goTypes = nil
-	file_github_com_golang_protobuf_ptypes_wrappers_wrappers_proto_depIdxs = nil
+	return 0
+}
+
+// Wrapper message for `float`.
+//
+// The JSON representation for `FloatValue` is JSON number.
+type FloatValue struct {
+	// The float value.
+	Value                float32  `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *FloatValue) Reset()         { *m = FloatValue{} }
+func (m *FloatValue) String() string { return proto.CompactTextString(m) }
+func (*FloatValue) ProtoMessage()    {}
+func (*FloatValue) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5377b62bda767935, []int{1}
+}
+
+func (*FloatValue) XXX_WellKnownType() string { return "FloatValue" }
+
+func (m *FloatValue) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FloatValue.Unmarshal(m, b)
+}
+func (m *FloatValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FloatValue.Marshal(b, m, deterministic)
+}
+func (m *FloatValue) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FloatValue.Merge(m, src)
+}
+func (m *FloatValue) XXX_Size() int {
+	return xxx_messageInfo_FloatValue.Size(m)
+}
+func (m *FloatValue) XXX_DiscardUnknown() {
+	xxx_messageInfo_FloatValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FloatValue proto.InternalMessageInfo
+
+func (m *FloatValue) GetValue() float32 {
+	if m != nil {
+		return m.Value
+	}
+	return 0
+}
+
+// Wrapper message for `int64`.
+//
+// The JSON representation for `Int64Value` is JSON string.
+type Int64Value struct {
+	// The int64 value.
+	Value                int64    `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Int64Value) Reset()         { *m = Int64Value{} }
+func (m *Int64Value) String() string { return proto.CompactTextString(m) }
+func (*Int64Value) ProtoMessage()    {}
+func (*Int64Value) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5377b62bda767935, []int{2}
+}
+
+func (*Int64Value) XXX_WellKnownType() string { return "Int64Value" }
+
+func (m *Int64Value) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Int64Value.Unmarshal(m, b)
+}
+func (m *Int64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Int64Value.Marshal(b, m, deterministic)
+}
+func (m *Int64Value) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Int64Value.Merge(m, src)
+}
+func (m *Int64Value) XXX_Size() int {
+	return xxx_messageInfo_Int64Value.Size(m)
+}
+func (m *Int64Value) XXX_DiscardUnknown() {
+	xxx_messageInfo_Int64Value.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Int64Value proto.InternalMessageInfo
+
+func (m *Int64Value) GetValue() int64 {
+	if m != nil {
+		return m.Value
+	}
+	return 0
+}
+
+// Wrapper message for `uint64`.
+//
+// The JSON representation for `UInt64Value` is JSON string.
+type UInt64Value struct {
+	// The uint64 value.
+	Value                uint64   `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UInt64Value) Reset()         { *m = UInt64Value{} }
+func (m *UInt64Value) String() string { return proto.CompactTextString(m) }
+func (*UInt64Value) ProtoMessage()    {}
+func (*UInt64Value) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5377b62bda767935, []int{3}
+}
+
+func (*UInt64Value) XXX_WellKnownType() string { return "UInt64Value" }
+
+func (m *UInt64Value) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UInt64Value.Unmarshal(m, b)
+}
+func (m *UInt64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UInt64Value.Marshal(b, m, deterministic)
+}
+func (m *UInt64Value) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UInt64Value.Merge(m, src)
+}
+func (m *UInt64Value) XXX_Size() int {
+	return xxx_messageInfo_UInt64Value.Size(m)
+}
+func (m *UInt64Value) XXX_DiscardUnknown() {
+	xxx_messageInfo_UInt64Value.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UInt64Value proto.InternalMessageInfo
+
+func (m *UInt64Value) GetValue() uint64 {
+	if m != nil {
+		return m.Value
+	}
+	return 0
+}
+
+// Wrapper message for `int32`.
+//
+// The JSON representation for `Int32Value` is JSON number.
+type Int32Value struct {
+	// The int32 value.
+	Value                int32    `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Int32Value) Reset()         { *m = Int32Value{} }
+func (m *Int32Value) String() string { return proto.CompactTextString(m) }
+func (*Int32Value) ProtoMessage()    {}
+func (*Int32Value) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5377b62bda767935, []int{4}
+}
+
+func (*Int32Value) XXX_WellKnownType() string { return "Int32Value" }
+
+func (m *Int32Value) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Int32Value.Unmarshal(m, b)
+}
+func (m *Int32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Int32Value.Marshal(b, m, deterministic)
+}
+func (m *Int32Value) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Int32Value.Merge(m, src)
+}
+func (m *Int32Value) XXX_Size() int {
+	return xxx_messageInfo_Int32Value.Size(m)
+}
+func (m *Int32Value) XXX_DiscardUnknown() {
+	xxx_messageInfo_Int32Value.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Int32Value proto.InternalMessageInfo
+
+func (m *Int32Value) GetValue() int32 {
+	if m != nil {
+		return m.Value
+	}
+	return 0
+}
+
+// Wrapper message for `uint32`.
+//
+// The JSON representation for `UInt32Value` is JSON number.
+type UInt32Value struct {
+	// The uint32 value.
+	Value                uint32   `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UInt32Value) Reset()         { *m = UInt32Value{} }
+func (m *UInt32Value) String() string { return proto.CompactTextString(m) }
+func (*UInt32Value) ProtoMessage()    {}
+func (*UInt32Value) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5377b62bda767935, []int{5}
+}
+
+func (*UInt32Value) XXX_WellKnownType() string { return "UInt32Value" }
+
+func (m *UInt32Value) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UInt32Value.Unmarshal(m, b)
+}
+func (m *UInt32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UInt32Value.Marshal(b, m, deterministic)
+}
+func (m *UInt32Value) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UInt32Value.Merge(m, src)
+}
+func (m *UInt32Value) XXX_Size() int {
+	return xxx_messageInfo_UInt32Value.Size(m)
+}
+func (m *UInt32Value) XXX_DiscardUnknown() {
+	xxx_messageInfo_UInt32Value.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UInt32Value proto.InternalMessageInfo
+
+func (m *UInt32Value) GetValue() uint32 {
+	if m != nil {
+		return m.Value
+	}
+	return 0
+}
+
+// Wrapper message for `bool`.
+//
+// The JSON representation for `BoolValue` is JSON `true` and `false`.
+type BoolValue struct {
+	// The bool value.
+	Value                bool     `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BoolValue) Reset()         { *m = BoolValue{} }
+func (m *BoolValue) String() string { return proto.CompactTextString(m) }
+func (*BoolValue) ProtoMessage()    {}
+func (*BoolValue) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5377b62bda767935, []int{6}
+}
+
+func (*BoolValue) XXX_WellKnownType() string { return "BoolValue" }
+
+func (m *BoolValue) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BoolValue.Unmarshal(m, b)
+}
+func (m *BoolValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BoolValue.Marshal(b, m, deterministic)
+}
+func (m *BoolValue) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BoolValue.Merge(m, src)
+}
+func (m *BoolValue) XXX_Size() int {
+	return xxx_messageInfo_BoolValue.Size(m)
+}
+func (m *BoolValue) XXX_DiscardUnknown() {
+	xxx_messageInfo_BoolValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BoolValue proto.InternalMessageInfo
+
+func (m *BoolValue) GetValue() bool {
+	if m != nil {
+		return m.Value
+	}
+	return false
+}
+
+// Wrapper message for `string`.
+//
+// The JSON representation for `StringValue` is JSON string.
+type StringValue struct {
+	// The string value.
+	Value                string   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StringValue) Reset()         { *m = StringValue{} }
+func (m *StringValue) String() string { return proto.CompactTextString(m) }
+func (*StringValue) ProtoMessage()    {}
+func (*StringValue) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5377b62bda767935, []int{7}
+}
+
+func (*StringValue) XXX_WellKnownType() string { return "StringValue" }
+
+func (m *StringValue) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_StringValue.Unmarshal(m, b)
+}
+func (m *StringValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_StringValue.Marshal(b, m, deterministic)
+}
+func (m *StringValue) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_StringValue.Merge(m, src)
+}
+func (m *StringValue) XXX_Size() int {
+	return xxx_messageInfo_StringValue.Size(m)
+}
+func (m *StringValue) XXX_DiscardUnknown() {
+	xxx_messageInfo_StringValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StringValue proto.InternalMessageInfo
+
+func (m *StringValue) GetValue() string {
+	if m != nil {
+		return m.Value
+	}
+	return ""
+}
+
+// Wrapper message for `bytes`.
+//
+// The JSON representation for `BytesValue` is JSON string.
+type BytesValue struct {
+	// The bytes value.
+	Value                []byte   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BytesValue) Reset()         { *m = BytesValue{} }
+func (m *BytesValue) String() string { return proto.CompactTextString(m) }
+func (*BytesValue) ProtoMessage()    {}
+func (*BytesValue) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5377b62bda767935, []int{8}
+}
+
+func (*BytesValue) XXX_WellKnownType() string { return "BytesValue" }
+
+func (m *BytesValue) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BytesValue.Unmarshal(m, b)
+}
+func (m *BytesValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BytesValue.Marshal(b, m, deterministic)
+}
+func (m *BytesValue) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BytesValue.Merge(m, src)
+}
+func (m *BytesValue) XXX_Size() int {
+	return xxx_messageInfo_BytesValue.Size(m)
+}
+func (m *BytesValue) XXX_DiscardUnknown() {
+	xxx_messageInfo_BytesValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BytesValue proto.InternalMessageInfo
+
+func (m *BytesValue) GetValue() []byte {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue")
+	proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue")
+	proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value")
+	proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value")
+	proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value")
+	proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value")
+	proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue")
+	proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue")
+	proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue")
+}
+
+func init() { proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor_5377b62bda767935) }
+
+var fileDescriptor_5377b62bda767935 = []byte{
+	// 259 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
+	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c,
+	0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca,
+	0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c,
+	0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5,
+	0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13,
+	0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8,
+	0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca,
+	0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a,
+	0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x0d,
+	0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x5a, 0xe8, 0x3a, 0xf1, 0x86, 0x43, 0x83, 0x3f, 0x00, 0x24,
+	0x12, 0xc0, 0x18, 0xa5, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f,
+	0x9e, 0x9f, 0x93, 0x98, 0x97, 0x8e, 0x88, 0xaa, 0x82, 0x92, 0xca, 0x82, 0xd4, 0x62, 0x78, 0x8c,
+	0xfd, 0x60, 0x64, 0x5c, 0xc4, 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e,
+	0x00, 0x54, 0xa9, 0x5e, 0x78, 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b,
+	0x12, 0x1b, 0xd8, 0x0c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x19, 0x6c, 0xb9, 0xb8, 0xfe,
+	0x01, 0x00, 0x00,
 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto
new file mode 100644
index 0000000..0194763
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto
@@ -0,0 +1,118 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Wrappers for primitive (non-message) types. These types are useful
+// for embedding primitives in the `google.protobuf.Any` type and for places
+// where we need to distinguish between the absence of a primitive
+// typed field and its default value.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/wrappers";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "WrappersProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// Wrapper message for `double`.
+//
+// The JSON representation for `DoubleValue` is JSON number.
+message DoubleValue {
+  // The double value.
+  double value = 1;
+}
+
+// Wrapper message for `float`.
+//
+// The JSON representation for `FloatValue` is JSON number.
+message FloatValue {
+  // The float value.
+  float value = 1;
+}
+
+// Wrapper message for `int64`.
+//
+// The JSON representation for `Int64Value` is JSON string.
+message Int64Value {
+  // The int64 value.
+  int64 value = 1;
+}
+
+// Wrapper message for `uint64`.
+//
+// The JSON representation for `UInt64Value` is JSON string.
+message UInt64Value {
+  // The uint64 value.
+  uint64 value = 1;
+}
+
+// Wrapper message for `int32`.
+//
+// The JSON representation for `Int32Value` is JSON number.
+message Int32Value {
+  // The int32 value.
+  int32 value = 1;
+}
+
+// Wrapper message for `uint32`.
+//
+// The JSON representation for `UInt32Value` is JSON number.
+message UInt32Value {
+  // The uint32 value.
+  uint32 value = 1;
+}
+
+// Wrapper message for `bool`.
+//
+// The JSON representation for `BoolValue` is JSON `true` and `false`.
+message BoolValue {
+  // The bool value.
+  bool value = 1;
+}
+
+// Wrapper message for `string`.
+//
+// The JSON representation for `StringValue` is JSON string.
+message StringValue {
+  // The string value.
+  string value = 1;
+}
+
+// Wrapper message for `bytes`.
+//
+// The JSON representation for `BytesValue` is JSON string.
+message BytesValue {
+  // The bytes value.
+  bytes value = 1;
+}
diff --git a/vendor/google.golang.org/protobuf/AUTHORS b/vendor/google.golang.org/protobuf/AUTHORS
deleted file mode 100644
index 2b00ddb..0000000
--- a/vendor/google.golang.org/protobuf/AUTHORS
+++ /dev/null
@@ -1,3 +0,0 @@
-# This source code refers to The Go Authors for copyright purposes.
-# The master list of authors is in the main Go distribution,
-# visible at https://tip.golang.org/AUTHORS.
diff --git a/vendor/google.golang.org/protobuf/CONTRIBUTORS b/vendor/google.golang.org/protobuf/CONTRIBUTORS
deleted file mode 100644
index 1fbd3e9..0000000
--- a/vendor/google.golang.org/protobuf/CONTRIBUTORS
+++ /dev/null
@@ -1,3 +0,0 @@
-# This source code was written by the Go contributors.
-# The master list of contributors is in the main Go distribution,
-# visible at https://tip.golang.org/CONTRIBUTORS.
diff --git a/vendor/google.golang.org/protobuf/LICENSE b/vendor/google.golang.org/protobuf/LICENSE
deleted file mode 100644
index 49ea0f9..0000000
--- a/vendor/google.golang.org/protobuf/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright (c) 2018 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/google.golang.org/protobuf/PATENTS b/vendor/google.golang.org/protobuf/PATENTS
deleted file mode 100644
index 7330990..0000000
--- a/vendor/google.golang.org/protobuf/PATENTS
+++ /dev/null
@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go.  This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation.  If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/decode.go b/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
deleted file mode 100644
index 71c755c..0000000
--- a/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
+++ /dev/null
@@ -1,683 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protojson
-
-import (
-	"encoding/base64"
-	"fmt"
-	"math"
-	"strconv"
-	"strings"
-
-	"google.golang.org/protobuf/internal/encoding/json"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/flags"
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/internal/set"
-	"google.golang.org/protobuf/proto"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// Unmarshal reads the given []byte into the given proto.Message.
-func Unmarshal(b []byte, m proto.Message) error {
-	return UnmarshalOptions{}.Unmarshal(b, m)
-}
-
-// UnmarshalOptions is a configurable JSON format parser.
-type UnmarshalOptions struct {
-	pragma.NoUnkeyedLiterals
-
-	// If AllowPartial is set, input for messages that will result in missing
-	// required fields will not return an error.
-	AllowPartial bool
-
-	// If DiscardUnknown is set, unknown fields are ignored.
-	DiscardUnknown bool
-
-	// Resolver is used for looking up types when unmarshaling
-	// google.protobuf.Any messages or extension fields.
-	// If nil, this defaults to using protoregistry.GlobalTypes.
-	Resolver interface {
-		protoregistry.MessageTypeResolver
-		protoregistry.ExtensionTypeResolver
-	}
-}
-
-// Unmarshal reads the given []byte and populates the given proto.Message using
-// options in UnmarshalOptions object. It will clear the message first before
-// setting the fields. If it returns an error, the given message may be
-// partially set.
-func (o UnmarshalOptions) Unmarshal(b []byte, m proto.Message) error {
-	proto.Reset(m)
-
-	if o.Resolver == nil {
-		o.Resolver = protoregistry.GlobalTypes
-	}
-
-	dec := decoder{json.NewDecoder(b), o}
-	if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
-		return err
-	}
-
-	// Check for EOF.
-	tok, err := dec.Read()
-	if err != nil {
-		return err
-	}
-	if tok.Kind() != json.EOF {
-		return dec.unexpectedTokenError(tok)
-	}
-
-	if o.AllowPartial {
-		return nil
-	}
-	return proto.CheckInitialized(m)
-}
-
-type decoder struct {
-	*json.Decoder
-	opts UnmarshalOptions
-}
-
-// newError returns an error object with position info.
-func (d decoder) newError(pos int, f string, x ...interface{}) error {
-	line, column := d.Position(pos)
-	head := fmt.Sprintf("(line %d:%d): ", line, column)
-	return errors.New(head+f, x...)
-}
-
-// unexpectedTokenError returns a syntax error for the given unexpected token.
-func (d decoder) unexpectedTokenError(tok json.Token) error {
-	return d.syntaxError(tok.Pos(), "unexpected token %s", tok.RawString())
-}
-
-// syntaxError returns a syntax error for given position.
-func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {
-	line, column := d.Position(pos)
-	head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
-	return errors.New(head+f, x...)
-}
-
-// unmarshalMessage unmarshals a message into the given protoreflect.Message.
-func (d decoder) unmarshalMessage(m pref.Message, skipTypeURL bool) error {
-	if isCustomType(m.Descriptor().FullName()) {
-		return d.unmarshalCustomType(m)
-	}
-
-	tok, err := d.Read()
-	if err != nil {
-		return err
-	}
-	if tok.Kind() != json.ObjectOpen {
-		return d.unexpectedTokenError(tok)
-	}
-
-	if err := d.unmarshalFields(m, skipTypeURL); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// unmarshalFields unmarshals the fields into the given protoreflect.Message.
-func (d decoder) unmarshalFields(m pref.Message, skipTypeURL bool) error {
-	messageDesc := m.Descriptor()
-	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
-		return errors.New("no support for proto1 MessageSets")
-	}
-
-	var seenNums set.Ints
-	var seenOneofs set.Ints
-	fieldDescs := messageDesc.Fields()
-	for {
-		// Read field name.
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		switch tok.Kind() {
-		default:
-			return d.unexpectedTokenError(tok)
-		case json.ObjectClose:
-			return nil
-		case json.Name:
-			// Continue below.
-		}
-
-		name := tok.Name()
-		// Unmarshaling a non-custom embedded message in Any will contain the
-		// JSON field "@type" which should be skipped because it is not a field
-		// of the embedded message, but simply an artifact of the Any format.
-		if skipTypeURL && name == "@type" {
-			d.Read()
-			continue
-		}
-
-		// Get the FieldDescriptor.
-		var fd pref.FieldDescriptor
-		if strings.HasPrefix(name, "[") && strings.HasSuffix(name, "]") {
-			// Only extension names are in [name] format.
-			extName := pref.FullName(name[1 : len(name)-1])
-			extType, err := d.findExtension(extName)
-			if err != nil && err != protoregistry.NotFound {
-				return d.newError(tok.Pos(), "unable to resolve %s: %v", tok.RawString(), err)
-			}
-			if extType != nil {
-				fd = extType.TypeDescriptor()
-				if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {
-					return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())
-				}
-			}
-		} else {
-			// The name can either be the JSON name or the proto field name.
-			fd = fieldDescs.ByJSONName(name)
-			if fd == nil {
-				fd = fieldDescs.ByName(pref.Name(name))
-				if fd == nil {
-					// The proto name of a group field is in all lowercase,
-					// while the textual field name is the group message name.
-					gd := fieldDescs.ByName(pref.Name(strings.ToLower(name)))
-					if gd != nil && gd.Kind() == pref.GroupKind && gd.Message().Name() == pref.Name(name) {
-						fd = gd
-					}
-				} else if fd.Kind() == pref.GroupKind && fd.Message().Name() != pref.Name(name) {
-					fd = nil // reset since field name is actually the message name
-				}
-			}
-		}
-		if flags.ProtoLegacy {
-			if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {
-				fd = nil // reset since the weak reference is not linked in
-			}
-		}
-
-		if fd == nil {
-			// Field is unknown.
-			if d.opts.DiscardUnknown {
-				if err := d.skipJSONValue(); err != nil {
-					return err
-				}
-				continue
-			}
-			return d.newError(tok.Pos(), "unknown field %v", tok.RawString())
-		}
-
-		// Do not allow duplicate fields.
-		num := uint64(fd.Number())
-		if seenNums.Has(num) {
-			return d.newError(tok.Pos(), "duplicate field %v", tok.RawString())
-		}
-		seenNums.Set(num)
-
-		// No need to set values for JSON null unless the field type is
-		// google.protobuf.Value or google.protobuf.NullValue.
-		if tok, _ := d.Peek(); tok.Kind() == json.Null && !isKnownValue(fd) && !isNullValue(fd) {
-			d.Read()
-			continue
-		}
-
-		switch {
-		case fd.IsList():
-			list := m.Mutable(fd).List()
-			if err := d.unmarshalList(list, fd); err != nil {
-				return err
-			}
-		case fd.IsMap():
-			mmap := m.Mutable(fd).Map()
-			if err := d.unmarshalMap(mmap, fd); err != nil {
-				return err
-			}
-		default:
-			// If field is a oneof, check if it has already been set.
-			if od := fd.ContainingOneof(); od != nil {
-				idx := uint64(od.Index())
-				if seenOneofs.Has(idx) {
-					return d.newError(tok.Pos(), "error parsing %s, oneof %v is already set", tok.RawString(), od.FullName())
-				}
-				seenOneofs.Set(idx)
-			}
-
-			// Required or optional fields.
-			if err := d.unmarshalSingular(m, fd); err != nil {
-				return err
-			}
-		}
-	}
-}
-
-// findExtension returns protoreflect.ExtensionType from the resolver if found.
-func (d decoder) findExtension(xtName pref.FullName) (pref.ExtensionType, error) {
-	xt, err := d.opts.Resolver.FindExtensionByName(xtName)
-	if err == nil {
-		return xt, nil
-	}
-	return messageset.FindMessageSetExtension(d.opts.Resolver, xtName)
-}
-
-func isKnownValue(fd pref.FieldDescriptor) bool {
-	md := fd.Message()
-	return md != nil && md.FullName() == "google.protobuf.Value"
-}
-
-func isNullValue(fd pref.FieldDescriptor) bool {
-	ed := fd.Enum()
-	return ed != nil && ed.FullName() == "google.protobuf.NullValue"
-}
-
-// unmarshalSingular unmarshals to the non-repeated field specified
-// by the given FieldDescriptor.
-func (d decoder) unmarshalSingular(m pref.Message, fd pref.FieldDescriptor) error {
-	var val pref.Value
-	var err error
-	switch fd.Kind() {
-	case pref.MessageKind, pref.GroupKind:
-		val = m.NewField(fd)
-		err = d.unmarshalMessage(val.Message(), false)
-	default:
-		val, err = d.unmarshalScalar(fd)
-	}
-
-	if err != nil {
-		return err
-	}
-	m.Set(fd, val)
-	return nil
-}
-
-// unmarshalScalar unmarshals to a scalar/enum protoreflect.Value specified by
-// the given FieldDescriptor.
-func (d decoder) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error) {
-	const b32 int = 32
-	const b64 int = 64
-
-	tok, err := d.Read()
-	if err != nil {
-		return pref.Value{}, err
-	}
-
-	kind := fd.Kind()
-	switch kind {
-	case pref.BoolKind:
-		if tok.Kind() == json.Bool {
-			return pref.ValueOfBool(tok.Bool()), nil
-		}
-
-	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
-		if v, ok := unmarshalInt(tok, b32); ok {
-			return v, nil
-		}
-
-	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-		if v, ok := unmarshalInt(tok, b64); ok {
-			return v, nil
-		}
-
-	case pref.Uint32Kind, pref.Fixed32Kind:
-		if v, ok := unmarshalUint(tok, b32); ok {
-			return v, nil
-		}
-
-	case pref.Uint64Kind, pref.Fixed64Kind:
-		if v, ok := unmarshalUint(tok, b64); ok {
-			return v, nil
-		}
-
-	case pref.FloatKind:
-		if v, ok := unmarshalFloat(tok, b32); ok {
-			return v, nil
-		}
-
-	case pref.DoubleKind:
-		if v, ok := unmarshalFloat(tok, b64); ok {
-			return v, nil
-		}
-
-	case pref.StringKind:
-		if tok.Kind() == json.String {
-			return pref.ValueOfString(tok.ParsedString()), nil
-		}
-
-	case pref.BytesKind:
-		if v, ok := unmarshalBytes(tok); ok {
-			return v, nil
-		}
-
-	case pref.EnumKind:
-		if v, ok := unmarshalEnum(tok, fd); ok {
-			return v, nil
-		}
-
-	default:
-		panic(fmt.Sprintf("unmarshalScalar: invalid scalar kind %v", kind))
-	}
-
-	return pref.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
-}
-
-func unmarshalInt(tok json.Token, bitSize int) (pref.Value, bool) {
-	switch tok.Kind() {
-	case json.Number:
-		return getInt(tok, bitSize)
-
-	case json.String:
-		// Decode number from string.
-		s := strings.TrimSpace(tok.ParsedString())
-		if len(s) != len(tok.ParsedString()) {
-			return pref.Value{}, false
-		}
-		dec := json.NewDecoder([]byte(s))
-		tok, err := dec.Read()
-		if err != nil {
-			return pref.Value{}, false
-		}
-		return getInt(tok, bitSize)
-	}
-	return pref.Value{}, false
-}
-
-func getInt(tok json.Token, bitSize int) (pref.Value, bool) {
-	n, ok := tok.Int(bitSize)
-	if !ok {
-		return pref.Value{}, false
-	}
-	if bitSize == 32 {
-		return pref.ValueOfInt32(int32(n)), true
-	}
-	return pref.ValueOfInt64(n), true
-}
-
-func unmarshalUint(tok json.Token, bitSize int) (pref.Value, bool) {
-	switch tok.Kind() {
-	case json.Number:
-		return getUint(tok, bitSize)
-
-	case json.String:
-		// Decode number from string.
-		s := strings.TrimSpace(tok.ParsedString())
-		if len(s) != len(tok.ParsedString()) {
-			return pref.Value{}, false
-		}
-		dec := json.NewDecoder([]byte(s))
-		tok, err := dec.Read()
-		if err != nil {
-			return pref.Value{}, false
-		}
-		return getUint(tok, bitSize)
-	}
-	return pref.Value{}, false
-}
-
-func getUint(tok json.Token, bitSize int) (pref.Value, bool) {
-	n, ok := tok.Uint(bitSize)
-	if !ok {
-		return pref.Value{}, false
-	}
-	if bitSize == 32 {
-		return pref.ValueOfUint32(uint32(n)), true
-	}
-	return pref.ValueOfUint64(n), true
-}
-
-func unmarshalFloat(tok json.Token, bitSize int) (pref.Value, bool) {
-	switch tok.Kind() {
-	case json.Number:
-		return getFloat(tok, bitSize)
-
-	case json.String:
-		s := tok.ParsedString()
-		switch s {
-		case "NaN":
-			if bitSize == 32 {
-				return pref.ValueOfFloat32(float32(math.NaN())), true
-			}
-			return pref.ValueOfFloat64(math.NaN()), true
-		case "Infinity":
-			if bitSize == 32 {
-				return pref.ValueOfFloat32(float32(math.Inf(+1))), true
-			}
-			return pref.ValueOfFloat64(math.Inf(+1)), true
-		case "-Infinity":
-			if bitSize == 32 {
-				return pref.ValueOfFloat32(float32(math.Inf(-1))), true
-			}
-			return pref.ValueOfFloat64(math.Inf(-1)), true
-		}
-
-		// Decode number from string.
-		if len(s) != len(strings.TrimSpace(s)) {
-			return pref.Value{}, false
-		}
-		dec := json.NewDecoder([]byte(s))
-		tok, err := dec.Read()
-		if err != nil {
-			return pref.Value{}, false
-		}
-		return getFloat(tok, bitSize)
-	}
-	return pref.Value{}, false
-}
-
-func getFloat(tok json.Token, bitSize int) (pref.Value, bool) {
-	n, ok := tok.Float(bitSize)
-	if !ok {
-		return pref.Value{}, false
-	}
-	if bitSize == 32 {
-		return pref.ValueOfFloat32(float32(n)), true
-	}
-	return pref.ValueOfFloat64(n), true
-}
-
-func unmarshalBytes(tok json.Token) (pref.Value, bool) {
-	if tok.Kind() != json.String {
-		return pref.Value{}, false
-	}
-
-	s := tok.ParsedString()
-	enc := base64.StdEncoding
-	if strings.ContainsAny(s, "-_") {
-		enc = base64.URLEncoding
-	}
-	if len(s)%4 != 0 {
-		enc = enc.WithPadding(base64.NoPadding)
-	}
-	b, err := enc.DecodeString(s)
-	if err != nil {
-		return pref.Value{}, false
-	}
-	return pref.ValueOfBytes(b), true
-}
-
-func unmarshalEnum(tok json.Token, fd pref.FieldDescriptor) (pref.Value, bool) {
-	switch tok.Kind() {
-	case json.String:
-		// Lookup EnumNumber based on name.
-		s := tok.ParsedString()
-		if enumVal := fd.Enum().Values().ByName(pref.Name(s)); enumVal != nil {
-			return pref.ValueOfEnum(enumVal.Number()), true
-		}
-
-	case json.Number:
-		if n, ok := tok.Int(32); ok {
-			return pref.ValueOfEnum(pref.EnumNumber(n)), true
-		}
-
-	case json.Null:
-		// This is only valid for google.protobuf.NullValue.
-		if isNullValue(fd) {
-			return pref.ValueOfEnum(0), true
-		}
-	}
-
-	return pref.Value{}, false
-}
-
-func (d decoder) unmarshalList(list pref.List, fd pref.FieldDescriptor) error {
-	tok, err := d.Read()
-	if err != nil {
-		return err
-	}
-	if tok.Kind() != json.ArrayOpen {
-		return d.unexpectedTokenError(tok)
-	}
-
-	switch fd.Kind() {
-	case pref.MessageKind, pref.GroupKind:
-		for {
-			tok, err := d.Peek()
-			if err != nil {
-				return err
-			}
-
-			if tok.Kind() == json.ArrayClose {
-				d.Read()
-				return nil
-			}
-
-			val := list.NewElement()
-			if err := d.unmarshalMessage(val.Message(), false); err != nil {
-				return err
-			}
-			list.Append(val)
-		}
-	default:
-		for {
-			tok, err := d.Peek()
-			if err != nil {
-				return err
-			}
-
-			if tok.Kind() == json.ArrayClose {
-				d.Read()
-				return nil
-			}
-
-			val, err := d.unmarshalScalar(fd)
-			if err != nil {
-				return err
-			}
-			list.Append(val)
-		}
-	}
-
-	return nil
-}
-
-func (d decoder) unmarshalMap(mmap pref.Map, fd pref.FieldDescriptor) error {
-	tok, err := d.Read()
-	if err != nil {
-		return err
-	}
-	if tok.Kind() != json.ObjectOpen {
-		return d.unexpectedTokenError(tok)
-	}
-
-	// Determine ahead whether map entry is a scalar type or a message type in
-	// order to call the appropriate unmarshalMapValue func inside the for loop
-	// below.
-	var unmarshalMapValue func() (pref.Value, error)
-	switch fd.MapValue().Kind() {
-	case pref.MessageKind, pref.GroupKind:
-		unmarshalMapValue = func() (pref.Value, error) {
-			val := mmap.NewValue()
-			if err := d.unmarshalMessage(val.Message(), false); err != nil {
-				return pref.Value{}, err
-			}
-			return val, nil
-		}
-	default:
-		unmarshalMapValue = func() (pref.Value, error) {
-			return d.unmarshalScalar(fd.MapValue())
-		}
-	}
-
-Loop:
-	for {
-		// Read field name.
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		switch tok.Kind() {
-		default:
-			return d.unexpectedTokenError(tok)
-		case json.ObjectClose:
-			break Loop
-		case json.Name:
-			// Continue.
-		}
-
-		// Unmarshal field name.
-		pkey, err := d.unmarshalMapKey(tok, fd.MapKey())
-		if err != nil {
-			return err
-		}
-
-		// Check for duplicate field name.
-		if mmap.Has(pkey) {
-			return d.newError(tok.Pos(), "duplicate map key %v", tok.RawString())
-		}
-
-		// Read and unmarshal field value.
-		pval, err := unmarshalMapValue()
-		if err != nil {
-			return err
-		}
-
-		mmap.Set(pkey, pval)
-	}
-
-	return nil
-}
-
-// unmarshalMapKey converts given token of Name kind into a protoreflect.MapKey.
-// A map key type is any integral or string type.
-func (d decoder) unmarshalMapKey(tok json.Token, fd pref.FieldDescriptor) (pref.MapKey, error) {
-	const b32 = 32
-	const b64 = 64
-	const base10 = 10
-
-	name := tok.Name()
-	kind := fd.Kind()
-	switch kind {
-	case pref.StringKind:
-		return pref.ValueOfString(name).MapKey(), nil
-
-	case pref.BoolKind:
-		switch name {
-		case "true":
-			return pref.ValueOfBool(true).MapKey(), nil
-		case "false":
-			return pref.ValueOfBool(false).MapKey(), nil
-		}
-
-	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
-		if n, err := strconv.ParseInt(name, base10, b32); err == nil {
-			return pref.ValueOfInt32(int32(n)).MapKey(), nil
-		}
-
-	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-		if n, err := strconv.ParseInt(name, base10, b64); err == nil {
-			return pref.ValueOfInt64(int64(n)).MapKey(), nil
-		}
-
-	case pref.Uint32Kind, pref.Fixed32Kind:
-		if n, err := strconv.ParseUint(name, base10, b32); err == nil {
-			return pref.ValueOfUint32(uint32(n)).MapKey(), nil
-		}
-
-	case pref.Uint64Kind, pref.Fixed64Kind:
-		if n, err := strconv.ParseUint(name, base10, b64); err == nil {
-			return pref.ValueOfUint64(uint64(n)).MapKey(), nil
-		}
-
-	default:
-		panic(fmt.Sprintf("invalid kind for map key: %v", kind))
-	}
-
-	return pref.MapKey{}, d.newError(tok.Pos(), "invalid value for %v key: %s", kind, tok.RawString())
-}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/doc.go b/vendor/google.golang.org/protobuf/encoding/protojson/doc.go
deleted file mode 100644
index 00ea2fe..0000000
--- a/vendor/google.golang.org/protobuf/encoding/protojson/doc.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protojson marshals and unmarshals protocol buffer messages as JSON
-// format. It follows the guide at
-// https://developers.google.com/protocol-buffers/docs/proto3#json.
-//
-// This package produces a different output than the standard "encoding/json"
-// package, which does not operate correctly on protocol buffer messages.
-package protojson
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/encode.go b/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
deleted file mode 100644
index e545feb..0000000
--- a/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
+++ /dev/null
@@ -1,394 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protojson
-
-import (
-	"encoding/base64"
-	"fmt"
-	"sort"
-
-	"google.golang.org/protobuf/internal/encoding/json"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/flags"
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/proto"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-const defaultIndent = "  "
-
-// Format formats the message as a multiline string.
-// This function is only intended for human consumption and ignores errors.
-// Do not depend on the output being stable. It may change over time across
-// different versions of the program.
-func Format(m proto.Message) string {
-	return MarshalOptions{Multiline: true}.Format(m)
-}
-
-// Marshal writes the given proto.Message in JSON format using default options.
-// Do not depend on the output being stable. It may change over time across
-// different versions of the program.
-func Marshal(m proto.Message) ([]byte, error) {
-	return MarshalOptions{}.Marshal(m)
-}
-
-// MarshalOptions is a configurable JSON format marshaler.
-type MarshalOptions struct {
-	pragma.NoUnkeyedLiterals
-
-	// Multiline specifies whether the marshaler should format the output in
-	// indented-form with every textual element on a new line.
-	// If Indent is an empty string, then an arbitrary indent is chosen.
-	Multiline bool
-
-	// Indent specifies the set of indentation characters to use in a multiline
-	// formatted output such that every entry is preceded by Indent and
-	// terminated by a newline. If non-empty, then Multiline is treated as true.
-	// Indent can only be composed of space or tab characters.
-	Indent string
-
-	// AllowPartial allows messages that have missing required fields to marshal
-	// without returning an error. If AllowPartial is false (the default),
-	// Marshal will return error if there are any missing required fields.
-	AllowPartial bool
-
-	// UseProtoNames uses proto field name instead of lowerCamelCase name in JSON
-	// field names.
-	UseProtoNames bool
-
-	// UseEnumNumbers emits enum values as numbers.
-	UseEnumNumbers bool
-
-	// EmitUnpopulated specifies whether to emit unpopulated fields. It does not
-	// emit unpopulated oneof fields or unpopulated extension fields.
-	// The JSON value emitted for unpopulated fields are as follows:
-	//  ╔═══════╤════════════════════════════╗
-	//  ║ JSON  │ Protobuf field             ║
-	//  ╠═══════╪════════════════════════════╣
-	//  ║ false │ proto3 boolean fields      ║
-	//  ║ 0     │ proto3 numeric fields      ║
-	//  ║ ""    │ proto3 string/bytes fields ║
-	//  ║ null  │ proto2 scalar fields       ║
-	//  ║ null  │ message fields             ║
-	//  ║ []    │ list fields                ║
-	//  ║ {}    │ map fields                 ║
-	//  ╚═══════╧════════════════════════════╝
-	EmitUnpopulated bool
-
-	// Resolver is used for looking up types when expanding google.protobuf.Any
-	// messages. If nil, this defaults to using protoregistry.GlobalTypes.
-	Resolver interface {
-		protoregistry.ExtensionTypeResolver
-		protoregistry.MessageTypeResolver
-	}
-}
-
-// Format formats the message as a string.
-// This method is only intended for human consumption and ignores errors.
-// Do not depend on the output being stable. It may change over time across
-// different versions of the program.
-func (o MarshalOptions) Format(m proto.Message) string {
-	if m == nil || !m.ProtoReflect().IsValid() {
-		return "<nil>" // invalid syntax, but okay since this is for debugging
-	}
-	o.AllowPartial = true
-	b, _ := o.Marshal(m)
-	return string(b)
-}
-
-// Marshal marshals the given proto.Message in the JSON format using options in
-// MarshalOptions. Do not depend on the output being stable. It may change over
-// time across different versions of the program.
-func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
-	if o.Multiline && o.Indent == "" {
-		o.Indent = defaultIndent
-	}
-	if o.Resolver == nil {
-		o.Resolver = protoregistry.GlobalTypes
-	}
-
-	internalEnc, err := json.NewEncoder(o.Indent)
-	if err != nil {
-		return nil, err
-	}
-
-	// Treat nil message interface as an empty message,
-	// in which case the output in an empty JSON object.
-	if m == nil {
-		return []byte("{}"), nil
-	}
-
-	enc := encoder{internalEnc, o}
-	if err := enc.marshalMessage(m.ProtoReflect()); err != nil {
-		return nil, err
-	}
-	if o.AllowPartial {
-		return enc.Bytes(), nil
-	}
-	return enc.Bytes(), proto.CheckInitialized(m)
-}
-
-type encoder struct {
-	*json.Encoder
-	opts MarshalOptions
-}
-
-// marshalMessage marshals the given protoreflect.Message.
-func (e encoder) marshalMessage(m pref.Message) error {
-	if isCustomType(m.Descriptor().FullName()) {
-		return e.marshalCustomType(m)
-	}
-
-	e.StartObject()
-	defer e.EndObject()
-	if err := e.marshalFields(m); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// marshalFields marshals the fields in the given protoreflect.Message.
-func (e encoder) marshalFields(m pref.Message) error {
-	messageDesc := m.Descriptor()
-	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
-		return errors.New("no support for proto1 MessageSets")
-	}
-
-	// Marshal out known fields.
-	fieldDescs := messageDesc.Fields()
-	for i := 0; i < fieldDescs.Len(); {
-		fd := fieldDescs.Get(i)
-		if od := fd.ContainingOneof(); od != nil {
-			fd = m.WhichOneof(od)
-			i += od.Fields().Len()
-			if fd == nil {
-				continue // unpopulated oneofs are not affected by EmitUnpopulated
-			}
-		} else {
-			i++
-		}
-
-		val := m.Get(fd)
-		if !m.Has(fd) {
-			if !e.opts.EmitUnpopulated {
-				continue
-			}
-			isProto2Scalar := fd.Syntax() == pref.Proto2 && fd.Default().IsValid()
-			isSingularMessage := fd.Cardinality() != pref.Repeated && fd.Message() != nil
-			if isProto2Scalar || isSingularMessage {
-				// Use invalid value to emit null.
-				val = pref.Value{}
-			}
-		}
-
-		name := fd.JSONName()
-		if e.opts.UseProtoNames {
-			name = string(fd.Name())
-			// Use type name for group field name.
-			if fd.Kind() == pref.GroupKind {
-				name = string(fd.Message().Name())
-			}
-		}
-		if err := e.WriteName(name); err != nil {
-			return err
-		}
-		if err := e.marshalValue(val, fd); err != nil {
-			return err
-		}
-	}
-
-	// Marshal out extensions.
-	if err := e.marshalExtensions(m); err != nil {
-		return err
-	}
-	return nil
-}
-
-// marshalValue marshals the given protoreflect.Value.
-func (e encoder) marshalValue(val pref.Value, fd pref.FieldDescriptor) error {
-	switch {
-	case fd.IsList():
-		return e.marshalList(val.List(), fd)
-	case fd.IsMap():
-		return e.marshalMap(val.Map(), fd)
-	default:
-		return e.marshalSingular(val, fd)
-	}
-}
-
-// marshalSingular marshals the given non-repeated field value. This includes
-// all scalar types, enums, messages, and groups.
-func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error {
-	if !val.IsValid() {
-		e.WriteNull()
-		return nil
-	}
-
-	switch kind := fd.Kind(); kind {
-	case pref.BoolKind:
-		e.WriteBool(val.Bool())
-
-	case pref.StringKind:
-		if e.WriteString(val.String()) != nil {
-			return errors.InvalidUTF8(string(fd.FullName()))
-		}
-
-	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
-		e.WriteInt(val.Int())
-
-	case pref.Uint32Kind, pref.Fixed32Kind:
-		e.WriteUint(val.Uint())
-
-	case pref.Int64Kind, pref.Sint64Kind, pref.Uint64Kind,
-		pref.Sfixed64Kind, pref.Fixed64Kind:
-		// 64-bit integers are written out as JSON string.
-		e.WriteString(val.String())
-
-	case pref.FloatKind:
-		// Encoder.WriteFloat handles the special numbers NaN and infinites.
-		e.WriteFloat(val.Float(), 32)
-
-	case pref.DoubleKind:
-		// Encoder.WriteFloat handles the special numbers NaN and infinites.
-		e.WriteFloat(val.Float(), 64)
-
-	case pref.BytesKind:
-		e.WriteString(base64.StdEncoding.EncodeToString(val.Bytes()))
-
-	case pref.EnumKind:
-		if fd.Enum().FullName() == "google.protobuf.NullValue" {
-			e.WriteNull()
-		} else {
-			desc := fd.Enum().Values().ByNumber(val.Enum())
-			if e.opts.UseEnumNumbers || desc == nil {
-				e.WriteInt(int64(val.Enum()))
-			} else {
-				e.WriteString(string(desc.Name()))
-			}
-		}
-
-	case pref.MessageKind, pref.GroupKind:
-		if err := e.marshalMessage(val.Message()); err != nil {
-			return err
-		}
-
-	default:
-		panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
-	}
-	return nil
-}
-
-// marshalList marshals the given protoreflect.List.
-func (e encoder) marshalList(list pref.List, fd pref.FieldDescriptor) error {
-	e.StartArray()
-	defer e.EndArray()
-
-	for i := 0; i < list.Len(); i++ {
-		item := list.Get(i)
-		if err := e.marshalSingular(item, fd); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-type mapEntry struct {
-	key   pref.MapKey
-	value pref.Value
-}
-
-// marshalMap marshals given protoreflect.Map.
-func (e encoder) marshalMap(mmap pref.Map, fd pref.FieldDescriptor) error {
-	e.StartObject()
-	defer e.EndObject()
-
-	// Get a sorted list based on keyType first.
-	entries := make([]mapEntry, 0, mmap.Len())
-	mmap.Range(func(key pref.MapKey, val pref.Value) bool {
-		entries = append(entries, mapEntry{key: key, value: val})
-		return true
-	})
-	sortMap(fd.MapKey().Kind(), entries)
-
-	// Write out sorted list.
-	for _, entry := range entries {
-		if err := e.WriteName(entry.key.String()); err != nil {
-			return err
-		}
-		if err := e.marshalSingular(entry.value, fd.MapValue()); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// sortMap orders list based on value of key field for deterministic ordering.
-func sortMap(keyKind pref.Kind, values []mapEntry) {
-	sort.Slice(values, func(i, j int) bool {
-		switch keyKind {
-		case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind,
-			pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-			return values[i].key.Int() < values[j].key.Int()
-
-		case pref.Uint32Kind, pref.Fixed32Kind,
-			pref.Uint64Kind, pref.Fixed64Kind:
-			return values[i].key.Uint() < values[j].key.Uint()
-		}
-		return values[i].key.String() < values[j].key.String()
-	})
-}
-
-// marshalExtensions marshals extension fields.
-func (e encoder) marshalExtensions(m pref.Message) error {
-	type entry struct {
-		key   string
-		value pref.Value
-		desc  pref.FieldDescriptor
-	}
-
-	// Get a sorted list based on field key first.
-	var entries []entry
-	m.Range(func(fd pref.FieldDescriptor, v pref.Value) bool {
-		if !fd.IsExtension() {
-			return true
-		}
-
-		// For MessageSet extensions, the name used is the parent message.
-		name := fd.FullName()
-		if messageset.IsMessageSetExtension(fd) {
-			name = name.Parent()
-		}
-
-		// Use [name] format for JSON field name.
-		entries = append(entries, entry{
-			key:   string(name),
-			value: v,
-			desc:  fd,
-		})
-		return true
-	})
-
-	// Sort extensions lexicographically.
-	sort.Slice(entries, func(i, j int) bool {
-		return entries[i].key < entries[j].key
-	})
-
-	// Write out sorted list.
-	for _, entry := range entries {
-		// JSON field name is the proto field name enclosed in [], similar to
-		// textproto. This is consistent with Go v1 lib. C++ lib v3.7.0 does not
-		// marshal out extension fields.
-		if err := e.WriteName("[" + entry.key + "]"); err != nil {
-			return err
-		}
-		if err := e.marshalValue(entry.value, entry.desc); err != nil {
-			return err
-		}
-	}
-	return nil
-}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go b/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
deleted file mode 100644
index 3c3ef14..0000000
--- a/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
+++ /dev/null
@@ -1,903 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protojson
-
-import (
-	"bytes"
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"google.golang.org/protobuf/internal/detectknown"
-	"google.golang.org/protobuf/internal/encoding/json"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/fieldnum"
-	"google.golang.org/protobuf/internal/strs"
-	"google.golang.org/protobuf/proto"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// isCustomType returns true if type name has special JSON conversion rules.
-// The list of custom types here has to match the ones in marshalCustomType and
-// unmarshalCustomType.
-func isCustomType(name pref.FullName) bool {
-	switch detectknown.Which(name) {
-	case detectknown.AnyProto:
-	case detectknown.TimestampProto:
-	case detectknown.DurationProto:
-	case detectknown.WrappersProto:
-	case detectknown.StructProto:
-	case detectknown.FieldMaskProto:
-	case detectknown.EmptyProto:
-	default:
-		return false
-	}
-	return true
-}
-
-// marshalCustomType marshals given well-known type message that have special
-// JSON conversion rules. It needs to be a message type where isCustomType
-// returns true, else it will panic.
-func (e encoder) marshalCustomType(m pref.Message) error {
-	name := m.Descriptor().FullName()
-	switch detectknown.Which(name) {
-	case detectknown.AnyProto:
-		return e.marshalAny(m)
-	case detectknown.TimestampProto:
-		return e.marshalTimestamp(m)
-	case detectknown.DurationProto:
-		return e.marshalDuration(m)
-	case detectknown.WrappersProto:
-		return e.marshalWrapperType(m)
-	case detectknown.StructProto:
-		return e.marshalStructType(m)
-	case detectknown.FieldMaskProto:
-		return e.marshalFieldMask(m)
-	case detectknown.EmptyProto:
-		return e.marshalEmpty(m)
-	default:
-		panic(fmt.Sprintf("%s does not have a custom marshaler", name))
-	}
-}
-
-// unmarshalCustomType unmarshals given well-known type message that have
-// special JSON conversion rules. It needs to be a message type where
-// isCustomType returns true, else it will panic.
-func (d decoder) unmarshalCustomType(m pref.Message) error {
-	name := m.Descriptor().FullName()
-	switch detectknown.Which(name) {
-	case detectknown.AnyProto:
-		return d.unmarshalAny(m)
-	case detectknown.TimestampProto:
-		return d.unmarshalTimestamp(m)
-	case detectknown.DurationProto:
-		return d.unmarshalDuration(m)
-	case detectknown.WrappersProto:
-		return d.unmarshalWrapperType(m)
-	case detectknown.StructProto:
-		return d.unmarshalStructType(m)
-	case detectknown.FieldMaskProto:
-		return d.unmarshalFieldMask(m)
-	case detectknown.EmptyProto:
-		return d.unmarshalEmpty(m)
-	default:
-		panic(fmt.Sprintf("%s does not have a custom unmarshaler", name))
-	}
-}
-
-// The JSON representation of an Any message uses the regular representation of
-// the deserialized, embedded message, with an additional field `@type` which
-// contains the type URL. If the embedded message type is well-known and has a
-// custom JSON representation, that representation will be embedded adding a
-// field `value` which holds the custom JSON in addition to the `@type` field.
-
-func (e encoder) marshalAny(m pref.Message) error {
-	fds := m.Descriptor().Fields()
-	fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
-	fdValue := fds.ByNumber(fieldnum.Any_Value)
-
-	// Start writing the JSON object.
-	e.StartObject()
-	defer e.EndObject()
-
-	if !m.Has(fdType) {
-		if !m.Has(fdValue) {
-			// If message is empty, marshal out empty JSON object.
-			return nil
-		} else {
-			// Return error if type_url field is not set, but value is set.
-			return errors.New("%s: type_url is not set", m.Descriptor().FullName())
-		}
-	}
-
-	typeVal := m.Get(fdType)
-	valueVal := m.Get(fdValue)
-
-	// Marshal out @type field.
-	typeURL := typeVal.String()
-	e.WriteName("@type")
-	if err := e.WriteString(typeURL); err != nil {
-		return err
-	}
-
-	// Resolve the type in order to unmarshal value field.
-	emt, err := e.opts.Resolver.FindMessageByURL(typeURL)
-	if err != nil {
-		return errors.New("%s: unable to resolve %q: %v", m.Descriptor().FullName(), typeURL, err)
-	}
-
-	em := emt.New()
-	err = proto.UnmarshalOptions{
-		AllowPartial: true, // never check required fields inside an Any
-		Resolver:     e.opts.Resolver,
-	}.Unmarshal(valueVal.Bytes(), em.Interface())
-	if err != nil {
-		return errors.New("%s: unable to unmarshal %q: %v", m.Descriptor().FullName(), typeURL, err)
-	}
-
-	// If type of value has custom JSON encoding, marshal out a field "value"
-	// with corresponding custom JSON encoding of the embedded message as a
-	// field.
-	if isCustomType(emt.Descriptor().FullName()) {
-		e.WriteName("value")
-		return e.marshalCustomType(em)
-	}
-
-	// Else, marshal out the embedded message's fields in this Any object.
-	if err := e.marshalFields(em); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (d decoder) unmarshalAny(m pref.Message) error {
-	// Peek to check for json.ObjectOpen to avoid advancing a read.
-	start, err := d.Peek()
-	if err != nil {
-		return err
-	}
-	if start.Kind() != json.ObjectOpen {
-		return d.unexpectedTokenError(start)
-	}
-
-	// Use another decoder to parse the unread bytes for @type field. This
-	// avoids advancing a read from current decoder because the current JSON
-	// object may contain the fields of the embedded type.
-	dec := decoder{d.Clone(), UnmarshalOptions{}}
-	tok, err := findTypeURL(dec)
-	switch err {
-	case errEmptyObject:
-		// An empty JSON object translates to an empty Any message.
-		d.Read() // Read json.ObjectOpen.
-		d.Read() // Read json.ObjectClose.
-		return nil
-
-	case errMissingType:
-		if d.opts.DiscardUnknown {
-			// Treat all fields as unknowns, similar to an empty object.
-			return d.skipJSONValue()
-		}
-		// Use start.Pos() for line position.
-		return d.newError(start.Pos(), err.Error())
-
-	default:
-		if err != nil {
-			return err
-		}
-	}
-
-	typeURL := tok.ParsedString()
-	emt, err := d.opts.Resolver.FindMessageByURL(typeURL)
-	if err != nil {
-		return d.newError(tok.Pos(), "unable to resolve %v: %q", tok.RawString(), err)
-	}
-
-	// Create new message for the embedded message type and unmarshal into it.
-	em := emt.New()
-	if isCustomType(emt.Descriptor().FullName()) {
-		// If embedded message is a custom type,
-		// unmarshal the JSON "value" field into it.
-		if err := d.unmarshalAnyValue(em); err != nil {
-			return err
-		}
-	} else {
-		// Else unmarshal the current JSON object into it.
-		if err := d.unmarshalMessage(em, true); err != nil {
-			return err
-		}
-	}
-	// Serialize the embedded message and assign the resulting bytes to the
-	// proto value field.
-	b, err := proto.MarshalOptions{
-		AllowPartial:  true, // No need to check required fields inside an Any.
-		Deterministic: true,
-	}.Marshal(em.Interface())
-	if err != nil {
-		return d.newError(start.Pos(), "error in marshaling Any.value field: %v", err)
-	}
-
-	fds := m.Descriptor().Fields()
-	fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
-	fdValue := fds.ByNumber(fieldnum.Any_Value)
-
-	m.Set(fdType, pref.ValueOfString(typeURL))
-	m.Set(fdValue, pref.ValueOfBytes(b))
-	return nil
-}
-
-var errEmptyObject = fmt.Errorf(`empty object`)
-var errMissingType = fmt.Errorf(`missing "@type" field`)
-
-// findTypeURL returns the token for the "@type" field value from the given
-// JSON bytes. It is expected that the given bytes start with json.ObjectOpen.
-// It returns errEmptyObject if the JSON object is empty or errMissingType if
-// @type field does not exist. It returns other error if the @type field is not
-// valid or other decoding issues.
-func findTypeURL(d decoder) (json.Token, error) {
-	var typeURL string
-	var typeTok json.Token
-	numFields := 0
-	// Skip start object.
-	d.Read()
-
-Loop:
-	for {
-		tok, err := d.Read()
-		if err != nil {
-			return json.Token{}, err
-		}
-
-		switch tok.Kind() {
-		case json.ObjectClose:
-			if typeURL == "" {
-				// Did not find @type field.
-				if numFields > 0 {
-					return json.Token{}, errMissingType
-				}
-				return json.Token{}, errEmptyObject
-			}
-			break Loop
-
-		case json.Name:
-			numFields++
-			if tok.Name() != "@type" {
-				// Skip value.
-				if err := d.skipJSONValue(); err != nil {
-					return json.Token{}, err
-				}
-				continue
-			}
-
-			// Return error if this was previously set already.
-			if typeURL != "" {
-				return json.Token{}, d.newError(tok.Pos(), `duplicate "@type" field`)
-			}
-			// Read field value.
-			tok, err := d.Read()
-			if err != nil {
-				return json.Token{}, err
-			}
-			if tok.Kind() != json.String {
-				return json.Token{}, d.newError(tok.Pos(), `@type field value is not a string: %v`, tok.RawString())
-			}
-			typeURL = tok.ParsedString()
-			if typeURL == "" {
-				return json.Token{}, d.newError(tok.Pos(), `@type field contains empty value`)
-			}
-			typeTok = tok
-		}
-	}
-
-	return typeTok, nil
-}
-
-// skipJSONValue parses a JSON value (null, boolean, string, number, object and
-// array) in order to advance the read to the next JSON value. It relies on
-// the decoder returning an error if the types are not in valid sequence.
-func (d decoder) skipJSONValue() error {
-	tok, err := d.Read()
-	if err != nil {
-		return err
-	}
-	// Only need to continue reading for objects and arrays.
-	switch tok.Kind() {
-	case json.ObjectOpen:
-		for {
-			tok, err := d.Read()
-			if err != nil {
-				return err
-			}
-			switch tok.Kind() {
-			case json.ObjectClose:
-				return nil
-			case json.Name:
-				// Skip object field value.
-				if err := d.skipJSONValue(); err != nil {
-					return err
-				}
-			}
-		}
-
-	case json.ArrayOpen:
-		for {
-			tok, err := d.Peek()
-			if err != nil {
-				return err
-			}
-			switch tok.Kind() {
-			case json.ArrayClose:
-				d.Read()
-				return nil
-			default:
-				// Skip array item.
-				if err := d.skipJSONValue(); err != nil {
-					return err
-				}
-			}
-		}
-	}
-	return nil
-}
-
-// unmarshalAnyValue unmarshals the given custom-type message from the JSON
-// object's "value" field.
-func (d decoder) unmarshalAnyValue(m pref.Message) error {
-	// Skip ObjectOpen, and start reading the fields.
-	d.Read()
-
-	var found bool // Used for detecting duplicate "value".
-	for {
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		switch tok.Kind() {
-		case json.ObjectClose:
-			if !found {
-				return d.newError(tok.Pos(), `missing "value" field`)
-			}
-			return nil
-
-		case json.Name:
-			switch tok.Name() {
-			case "@type":
-				// Skip the value as this was previously parsed already.
-				d.Read()
-
-			case "value":
-				if found {
-					return d.newError(tok.Pos(), `duplicate "value" field`)
-				}
-				// Unmarshal the field value into the given message.
-				if err := d.unmarshalCustomType(m); err != nil {
-					return err
-				}
-				found = true
-
-			default:
-				if d.opts.DiscardUnknown {
-					if err := d.skipJSONValue(); err != nil {
-						return err
-					}
-					continue
-				}
-				return d.newError(tok.Pos(), "unknown field %v", tok.RawString())
-			}
-		}
-	}
-}
-
-// Wrapper types are encoded as JSON primitives like string, number or boolean.
-
-// The "value" field has the same field number for all wrapper types.
-const wrapperFieldNumber = fieldnum.BoolValue_Value
-
-func (e encoder) marshalWrapperType(m pref.Message) error {
-	fd := m.Descriptor().Fields().ByNumber(wrapperFieldNumber)
-	val := m.Get(fd)
-	return e.marshalSingular(val, fd)
-}
-
-func (d decoder) unmarshalWrapperType(m pref.Message) error {
-	fd := m.Descriptor().Fields().ByNumber(wrapperFieldNumber)
-	val, err := d.unmarshalScalar(fd)
-	if err != nil {
-		return err
-	}
-	m.Set(fd, val)
-	return nil
-}
-
-// The JSON representation for Empty is an empty JSON object.
-
-func (e encoder) marshalEmpty(pref.Message) error {
-	e.StartObject()
-	e.EndObject()
-	return nil
-}
-
-func (d decoder) unmarshalEmpty(pref.Message) error {
-	tok, err := d.Read()
-	if err != nil {
-		return err
-	}
-	if tok.Kind() != json.ObjectOpen {
-		return d.unexpectedTokenError(tok)
-	}
-
-	for {
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		switch tok.Kind() {
-		case json.ObjectClose:
-			return nil
-
-		case json.Name:
-			if d.opts.DiscardUnknown {
-				if err := d.skipJSONValue(); err != nil {
-					return err
-				}
-				continue
-			}
-			return d.newError(tok.Pos(), "unknown field %v", tok.RawString())
-
-		default:
-			return d.unexpectedTokenError(tok)
-		}
-	}
-}
-
-func (e encoder) marshalStructType(m pref.Message) error {
-	switch m.Descriptor().Name() {
-	case "Struct":
-		return e.marshalStruct(m)
-	case "ListValue":
-		return e.marshalListValue(m)
-	case "Value":
-		return e.marshalKnownValue(m)
-	default:
-		panic(fmt.Sprintf("invalid struct type: %v", m.Descriptor().FullName()))
-	}
-}
-
-func (d decoder) unmarshalStructType(m pref.Message) error {
-	switch m.Descriptor().Name() {
-	case "Struct":
-		return d.unmarshalStruct(m)
-	case "ListValue":
-		return d.unmarshalListValue(m)
-	case "Value":
-		return d.unmarshalKnownValue(m)
-	default:
-		panic(fmt.Sprintf("invalid struct type: %v", m.Descriptor().FullName()))
-	}
-}
-
-// The JSON representation for Struct is a JSON object that contains the encoded
-// Struct.fields map and follows the serialization rules for a map.
-
-func (e encoder) marshalStruct(m pref.Message) error {
-	fd := m.Descriptor().Fields().ByNumber(fieldnum.Struct_Fields)
-	return e.marshalMap(m.Get(fd).Map(), fd)
-}
-
-func (d decoder) unmarshalStruct(m pref.Message) error {
-	fd := m.Descriptor().Fields().ByNumber(fieldnum.Struct_Fields)
-	return d.unmarshalMap(m.Mutable(fd).Map(), fd)
-}
-
-// The JSON representation for ListValue is JSON array that contains the encoded
-// ListValue.values repeated field and follows the serialization rules for a
-// repeated field.
-
-func (e encoder) marshalListValue(m pref.Message) error {
-	fd := m.Descriptor().Fields().ByNumber(fieldnum.ListValue_Values)
-	return e.marshalList(m.Get(fd).List(), fd)
-}
-
-func (d decoder) unmarshalListValue(m pref.Message) error {
-	fd := m.Descriptor().Fields().ByNumber(fieldnum.ListValue_Values)
-	return d.unmarshalList(m.Mutable(fd).List(), fd)
-}
-
-// The JSON representation for a Value is dependent on the oneof field that is
-// set. Each of the field in the oneof has its own custom serialization rule. A
-// Value message needs to be a oneof field set, else it is an error.
-
-func (e encoder) marshalKnownValue(m pref.Message) error {
-	od := m.Descriptor().Oneofs().ByName("kind")
-	fd := m.WhichOneof(od)
-	if fd == nil {
-		return errors.New("%s: none of the oneof fields is set", m.Descriptor().FullName())
-	}
-	return e.marshalSingular(m.Get(fd), fd)
-}
-
-func (d decoder) unmarshalKnownValue(m pref.Message) error {
-	tok, err := d.Peek()
-	if err != nil {
-		return err
-	}
-
-	var fd pref.FieldDescriptor
-	var val pref.Value
-	switch tok.Kind() {
-	case json.Null:
-		d.Read()
-		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_NullValue)
-		val = pref.ValueOfEnum(0)
-
-	case json.Bool:
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_BoolValue)
-		val = pref.ValueOfBool(tok.Bool())
-
-	case json.Number:
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_NumberValue)
-		var ok bool
-		val, ok = unmarshalFloat(tok, 64)
-		if !ok {
-			return d.newError(tok.Pos(), "invalid google.protobuf.Value: %v", tok.RawString())
-		}
-
-	case json.String:
-		// A JSON string may have been encoded from the number_value field,
-		// e.g. "NaN", "Infinity", etc. Parsing a proto double type also allows
-		// for it to be in JSON string form. Given this custom encoding spec,
-		// however, there is no way to identify that and hence a JSON string is
-		// always assigned to the string_value field, which means that certain
-		// encoding cannot be parsed back to the same field.
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_StringValue)
-		val = pref.ValueOfString(tok.ParsedString())
-
-	case json.ObjectOpen:
-		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_StructValue)
-		val = m.NewField(fd)
-		if err := d.unmarshalStruct(val.Message()); err != nil {
-			return err
-		}
-
-	case json.ArrayOpen:
-		fd = m.Descriptor().Fields().ByNumber(fieldnum.Value_ListValue)
-		val = m.NewField(fd)
-		if err := d.unmarshalListValue(val.Message()); err != nil {
-			return err
-		}
-
-	default:
-		return d.newError(tok.Pos(), "invalid google.protobuf.Value: %v", tok.RawString())
-	}
-
-	m.Set(fd, val)
-	return nil
-}
-
-// The JSON representation for a Duration is a JSON string that ends in the
-// suffix "s" (indicating seconds) and is preceded by the number of seconds,
-// with nanoseconds expressed as fractional seconds.
-//
-// Durations less than one second are represented with a 0 seconds field and a
-// positive or negative nanos field. For durations of one second or more, a
-// non-zero value for the nanos field must be of the same sign as the seconds
-// field.
-//
-// Duration.seconds must be from -315,576,000,000 to +315,576,000,000 inclusive.
-// Duration.nanos must be from -999,999,999 to +999,999,999 inclusive.
-
-const (
-	secondsInNanos       = 999999999
-	maxSecondsInDuration = 315576000000
-)
-
-func (e encoder) marshalDuration(m pref.Message) error {
-	fds := m.Descriptor().Fields()
-	fdSeconds := fds.ByNumber(fieldnum.Duration_Seconds)
-	fdNanos := fds.ByNumber(fieldnum.Duration_Nanos)
-
-	secsVal := m.Get(fdSeconds)
-	nanosVal := m.Get(fdNanos)
-	secs := secsVal.Int()
-	nanos := nanosVal.Int()
-	if secs < -maxSecondsInDuration || secs > maxSecondsInDuration {
-		return errors.New("%s: seconds out of range %v", m.Descriptor().FullName(), secs)
-	}
-	if nanos < -secondsInNanos || nanos > secondsInNanos {
-		return errors.New("%s: nanos out of range %v", m.Descriptor().FullName(), nanos)
-	}
-	if (secs > 0 && nanos < 0) || (secs < 0 && nanos > 0) {
-		return errors.New("%s: signs of seconds and nanos do not match", m.Descriptor().FullName())
-	}
-	// Generated output always contains 0, 3, 6, or 9 fractional digits,
-	// depending on required precision, followed by the suffix "s".
-	f := "%d.%09d"
-	if nanos < 0 {
-		nanos = -nanos
-		if secs == 0 {
-			f = "-%d.%09d"
-		}
-	}
-	x := fmt.Sprintf(f, secs, nanos)
-	x = strings.TrimSuffix(x, "000")
-	x = strings.TrimSuffix(x, "000")
-	x = strings.TrimSuffix(x, ".000")
-	e.WriteString(x + "s")
-	return nil
-}
-
-func (d decoder) unmarshalDuration(m pref.Message) error {
-	tok, err := d.Read()
-	if err != nil {
-		return err
-	}
-	if tok.Kind() != json.String {
-		return d.unexpectedTokenError(tok)
-	}
-
-	secs, nanos, ok := parseDuration(tok.ParsedString())
-	if !ok {
-		return d.newError(tok.Pos(), "invalid google.protobuf.Duration value %v", tok.RawString())
-	}
-	// Validate seconds. No need to validate nanos because parseDuration would
-	// have covered that already.
-	if secs < -maxSecondsInDuration || secs > maxSecondsInDuration {
-		return d.newError(tok.Pos(), "google.protobuf.Duration value out of range: %v", tok.RawString())
-	}
-
-	fds := m.Descriptor().Fields()
-	fdSeconds := fds.ByNumber(fieldnum.Duration_Seconds)
-	fdNanos := fds.ByNumber(fieldnum.Duration_Nanos)
-
-	m.Set(fdSeconds, pref.ValueOfInt64(secs))
-	m.Set(fdNanos, pref.ValueOfInt32(nanos))
-	return nil
-}
-
-// parseDuration parses the given input string for seconds and nanoseconds value
-// for the Duration JSON format. The format is a decimal number with a suffix
-// 's'. It can have optional plus/minus sign. There needs to be at least an
-// integer or fractional part. Fractional part is limited to 9 digits only for
-// nanoseconds precision, regardless of whether there are trailing zero digits.
-// Example values are 1s, 0.1s, 1.s, .1s, +1s, -1s, -.1s.
-func parseDuration(input string) (int64, int32, bool) {
-	b := []byte(input)
-	size := len(b)
-	if size < 2 {
-		return 0, 0, false
-	}
-	if b[size-1] != 's' {
-		return 0, 0, false
-	}
-	b = b[:size-1]
-
-	// Read optional plus/minus symbol.
-	var neg bool
-	switch b[0] {
-	case '-':
-		neg = true
-		b = b[1:]
-	case '+':
-		b = b[1:]
-	}
-	if len(b) == 0 {
-		return 0, 0, false
-	}
-
-	// Read the integer part.
-	var intp []byte
-	switch {
-	case b[0] == '0':
-		b = b[1:]
-
-	case '1' <= b[0] && b[0] <= '9':
-		intp = b[0:]
-		b = b[1:]
-		n := 1
-		for len(b) > 0 && '0' <= b[0] && b[0] <= '9' {
-			n++
-			b = b[1:]
-		}
-		intp = intp[:n]
-
-	case b[0] == '.':
-		// Continue below.
-
-	default:
-		return 0, 0, false
-	}
-
-	hasFrac := false
-	var frac [9]byte
-	if len(b) > 0 {
-		if b[0] != '.' {
-			return 0, 0, false
-		}
-		// Read the fractional part.
-		b = b[1:]
-		n := 0
-		for len(b) > 0 && n < 9 && '0' <= b[0] && b[0] <= '9' {
-			frac[n] = b[0]
-			n++
-			b = b[1:]
-		}
-		// It is not valid if there are more bytes left.
-		if len(b) > 0 {
-			return 0, 0, false
-		}
-		// Pad fractional part with 0s.
-		for i := n; i < 9; i++ {
-			frac[i] = '0'
-		}
-		hasFrac = true
-	}
-
-	var secs int64
-	if len(intp) > 0 {
-		var err error
-		secs, err = strconv.ParseInt(string(intp), 10, 64)
-		if err != nil {
-			return 0, 0, false
-		}
-	}
-
-	var nanos int64
-	if hasFrac {
-		nanob := bytes.TrimLeft(frac[:], "0")
-		if len(nanob) > 0 {
-			var err error
-			nanos, err = strconv.ParseInt(string(nanob), 10, 32)
-			if err != nil {
-				return 0, 0, false
-			}
-		}
-	}
-
-	if neg {
-		if secs > 0 {
-			secs = -secs
-		}
-		if nanos > 0 {
-			nanos = -nanos
-		}
-	}
-	return secs, int32(nanos), true
-}
-
-// The JSON representation for a Timestamp is a JSON string in the RFC 3339
-// format, i.e. "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where
-// {year} is always expressed using four digits while {month}, {day}, {hour},
-// {min}, and {sec} are zero-padded to two digits each. The fractional seconds,
-// which can go up to 9 digits, up to 1 nanosecond resolution, is optional. The
-// "Z" suffix indicates the timezone ("UTC"); the timezone is required. Encoding
-// should always use UTC (as indicated by "Z") and a decoder should be able to
-// accept both UTC and other timezones (as indicated by an offset).
-//
-// Timestamp.seconds must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z
-// inclusive.
-// Timestamp.nanos must be from 0 to 999,999,999 inclusive.
-
-const (
-	maxTimestampSeconds = 253402300799
-	minTimestampSeconds = -62135596800
-)
-
-func (e encoder) marshalTimestamp(m pref.Message) error {
-	fds := m.Descriptor().Fields()
-	fdSeconds := fds.ByNumber(fieldnum.Timestamp_Seconds)
-	fdNanos := fds.ByNumber(fieldnum.Timestamp_Nanos)
-
-	secsVal := m.Get(fdSeconds)
-	nanosVal := m.Get(fdNanos)
-	secs := secsVal.Int()
-	nanos := nanosVal.Int()
-	if secs < minTimestampSeconds || secs > maxTimestampSeconds {
-		return errors.New("%s: seconds out of range %v", m.Descriptor().FullName(), secs)
-	}
-	if nanos < 0 || nanos > secondsInNanos {
-		return errors.New("%s: nanos out of range %v", m.Descriptor().FullName(), nanos)
-	}
-	// Uses RFC 3339, where generated output will be Z-normalized and uses 0, 3,
-	// 6 or 9 fractional digits.
-	t := time.Unix(secs, nanos).UTC()
-	x := t.Format("2006-01-02T15:04:05.000000000")
-	x = strings.TrimSuffix(x, "000")
-	x = strings.TrimSuffix(x, "000")
-	x = strings.TrimSuffix(x, ".000")
-	e.WriteString(x + "Z")
-	return nil
-}
-
-func (d decoder) unmarshalTimestamp(m pref.Message) error {
-	tok, err := d.Read()
-	if err != nil {
-		return err
-	}
-	if tok.Kind() != json.String {
-		return d.unexpectedTokenError(tok)
-	}
-
-	t, err := time.Parse(time.RFC3339Nano, tok.ParsedString())
-	if err != nil {
-		return d.newError(tok.Pos(), "invalid google.protobuf.Timestamp value %v", tok.RawString())
-	}
-	// Validate seconds. No need to validate nanos because time.Parse would have
-	// covered that already.
-	secs := t.Unix()
-	if secs < minTimestampSeconds || secs > maxTimestampSeconds {
-		return d.newError(tok.Pos(), "google.protobuf.Timestamp value out of range: %v", tok.RawString())
-	}
-
-	fds := m.Descriptor().Fields()
-	fdSeconds := fds.ByNumber(fieldnum.Timestamp_Seconds)
-	fdNanos := fds.ByNumber(fieldnum.Timestamp_Nanos)
-
-	m.Set(fdSeconds, pref.ValueOfInt64(secs))
-	m.Set(fdNanos, pref.ValueOfInt32(int32(t.Nanosecond())))
-	return nil
-}
-
-// The JSON representation for a FieldMask is a JSON string where paths are
-// separated by a comma. Fields name in each path are converted to/from
-// lower-camel naming conventions. Encoding should fail if the path name would
-// end up differently after a round-trip.
-
-func (e encoder) marshalFieldMask(m pref.Message) error {
-	fd := m.Descriptor().Fields().ByNumber(fieldnum.FieldMask_Paths)
-	list := m.Get(fd).List()
-	paths := make([]string, 0, list.Len())
-
-	for i := 0; i < list.Len(); i++ {
-		s := list.Get(i).String()
-		// Return error if conversion to camelCase is not reversible.
-		cc := strs.JSONCamelCase(s)
-		if s != strs.JSONSnakeCase(cc) {
-			return errors.New("%s.paths contains irreversible value %q", m.Descriptor().FullName(), s)
-		}
-		paths = append(paths, cc)
-	}
-
-	e.WriteString(strings.Join(paths, ","))
-	return nil
-}
-
-func (d decoder) unmarshalFieldMask(m pref.Message) error {
-	tok, err := d.Read()
-	if err != nil {
-		return err
-	}
-	if tok.Kind() != json.String {
-		return d.unexpectedTokenError(tok)
-	}
-	str := strings.TrimSpace(tok.ParsedString())
-	if str == "" {
-		return nil
-	}
-	paths := strings.Split(str, ",")
-
-	fd := m.Descriptor().Fields().ByNumber(fieldnum.FieldMask_Paths)
-	list := m.Mutable(fd).List()
-
-	for _, s := range paths {
-		s = strings.TrimSpace(s)
-		// Convert to snake_case. Unlike encoding, no validation is done because
-		// it is not possible to know the original path names.
-		list.Append(pref.ValueOfString(strs.JSONSnakeCase(s)))
-	}
-	return nil
-}
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/decode.go b/vendor/google.golang.org/protobuf/encoding/prototext/decode.go
deleted file mode 100644
index 77dbe1b..0000000
--- a/vendor/google.golang.org/protobuf/encoding/prototext/decode.go
+++ /dev/null
@@ -1,789 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package prototext
-
-import (
-	"fmt"
-	"strings"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/encoding/text"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/fieldnum"
-	"google.golang.org/protobuf/internal/flags"
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/internal/set"
-	"google.golang.org/protobuf/internal/strs"
-	"google.golang.org/protobuf/proto"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// Unmarshal reads the given []byte into the given proto.Message.
-func Unmarshal(b []byte, m proto.Message) error {
-	return UnmarshalOptions{}.Unmarshal(b, m)
-}
-
-// UnmarshalOptions is a configurable textproto format unmarshaler.
-type UnmarshalOptions struct {
-	pragma.NoUnkeyedLiterals
-
-	// AllowPartial accepts input for messages that will result in missing
-	// required fields. If AllowPartial is false (the default), Unmarshal will
-	// return error if there are any missing required fields.
-	AllowPartial bool
-
-	// DiscardUnknown specifies whether to ignore unknown fields when parsing.
-	// An unknown field is any field whose field name or field number does not
-	// resolve to any known or extension field in the message.
-	// By default, unmarshal rejects unknown fields as an error.
-	DiscardUnknown bool
-
-	// Resolver is used for looking up types when unmarshaling
-	// google.protobuf.Any messages or extension fields.
-	// If nil, this defaults to using protoregistry.GlobalTypes.
-	Resolver interface {
-		protoregistry.MessageTypeResolver
-		protoregistry.ExtensionTypeResolver
-	}
-}
-
-// Unmarshal reads the given []byte and populates the given proto.Message using options in
-// UnmarshalOptions object.
-func (o UnmarshalOptions) Unmarshal(b []byte, m proto.Message) error {
-	proto.Reset(m)
-
-	if o.Resolver == nil {
-		o.Resolver = protoregistry.GlobalTypes
-	}
-
-	dec := decoder{text.NewDecoder(b), o}
-	if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
-		return err
-	}
-	if o.AllowPartial {
-		return nil
-	}
-	return proto.CheckInitialized(m)
-}
-
-type decoder struct {
-	*text.Decoder
-	opts UnmarshalOptions
-}
-
-// newError returns an error object with position info.
-func (d decoder) newError(pos int, f string, x ...interface{}) error {
-	line, column := d.Position(pos)
-	head := fmt.Sprintf("(line %d:%d): ", line, column)
-	return errors.New(head+f, x...)
-}
-
-// unexpectedTokenError returns a syntax error for the given unexpected token.
-func (d decoder) unexpectedTokenError(tok text.Token) error {
-	return d.syntaxError(tok.Pos(), "unexpected token: %s", tok.RawString())
-}
-
-// syntaxError returns a syntax error for given position.
-func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {
-	line, column := d.Position(pos)
-	head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
-	return errors.New(head+f, x...)
-}
-
-// unmarshalMessage unmarshals into the given protoreflect.Message.
-func (d decoder) unmarshalMessage(m pref.Message, checkDelims bool) error {
-	messageDesc := m.Descriptor()
-	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
-		return errors.New("no support for proto1 MessageSets")
-	}
-
-	if messageDesc.FullName() == "google.protobuf.Any" {
-		return d.unmarshalAny(m, checkDelims)
-	}
-
-	if checkDelims {
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-
-		if tok.Kind() != text.MessageOpen {
-			return d.unexpectedTokenError(tok)
-		}
-	}
-
-	var seenNums set.Ints
-	var seenOneofs set.Ints
-	fieldDescs := messageDesc.Fields()
-
-	for {
-		// Read field name.
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		switch typ := tok.Kind(); typ {
-		case text.Name:
-			// Continue below.
-		case text.EOF:
-			if checkDelims {
-				return text.ErrUnexpectedEOF
-			}
-			return nil
-		default:
-			if checkDelims && typ == text.MessageClose {
-				return nil
-			}
-			return d.unexpectedTokenError(tok)
-		}
-
-		// Resolve the field descriptor.
-		var name pref.Name
-		var fd pref.FieldDescriptor
-		var xt pref.ExtensionType
-		var xtErr error
-		var isFieldNumberName bool
-
-		switch tok.NameKind() {
-		case text.IdentName:
-			name = pref.Name(tok.IdentName())
-			fd = fieldDescs.ByName(name)
-			if fd == nil {
-				// The proto name of a group field is in all lowercase,
-				// while the textproto field name is the group message name.
-				gd := fieldDescs.ByName(pref.Name(strings.ToLower(string(name))))
-				if gd != nil && gd.Kind() == pref.GroupKind && gd.Message().Name() == name {
-					fd = gd
-				}
-			} else if fd.Kind() == pref.GroupKind && fd.Message().Name() != name {
-				fd = nil // reset since field name is actually the message name
-			}
-
-		case text.TypeName:
-			// Handle extensions only. This code path is not for Any.
-			xt, xtErr = d.findExtension(pref.FullName(tok.TypeName()))
-
-		case text.FieldNumber:
-			isFieldNumberName = true
-			num := pref.FieldNumber(tok.FieldNumber())
-			if !num.IsValid() {
-				return d.newError(tok.Pos(), "invalid field number: %d", num)
-			}
-			fd = fieldDescs.ByNumber(num)
-			if fd == nil {
-				xt, xtErr = d.opts.Resolver.FindExtensionByNumber(messageDesc.FullName(), num)
-			}
-		}
-
-		if xt != nil {
-			fd = xt.TypeDescriptor()
-			if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {
-				return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())
-			}
-		} else if xtErr != nil && xtErr != protoregistry.NotFound {
-			return d.newError(tok.Pos(), "unable to resolve [%s]: %v", tok.RawString(), xtErr)
-		}
-		if flags.ProtoLegacy {
-			if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {
-				fd = nil // reset since the weak reference is not linked in
-			}
-		}
-
-		// Handle unknown fields.
-		if fd == nil {
-			if d.opts.DiscardUnknown || messageDesc.ReservedNames().Has(name) {
-				d.skipValue()
-				continue
-			}
-			return d.newError(tok.Pos(), "unknown field: %v", tok.RawString())
-		}
-
-		// Handle fields identified by field number.
-		if isFieldNumberName {
-			// TODO: Add an option to permit parsing field numbers.
-			//
-			// This requires careful thought as the MarshalOptions.EmitUnknown
-			// option allows formatting unknown fields as the field number and the
-			// best-effort textual representation of the field value.  In that case,
-			// it may not be possible to unmarshal the value from a parser that does
-			// have information about the unknown field.
-			return d.newError(tok.Pos(), "cannot specify field by number: %v", tok.RawString())
-		}
-
-		switch {
-		case fd.IsList():
-			kind := fd.Kind()
-			if kind != pref.MessageKind && kind != pref.GroupKind && !tok.HasSeparator() {
-				return d.syntaxError(tok.Pos(), "missing field separator :")
-			}
-
-			list := m.Mutable(fd).List()
-			if err := d.unmarshalList(fd, list); err != nil {
-				return err
-			}
-
-		case fd.IsMap():
-			mmap := m.Mutable(fd).Map()
-			if err := d.unmarshalMap(fd, mmap); err != nil {
-				return err
-			}
-
-		default:
-			kind := fd.Kind()
-			if kind != pref.MessageKind && kind != pref.GroupKind && !tok.HasSeparator() {
-				return d.syntaxError(tok.Pos(), "missing field separator :")
-			}
-
-			// If field is a oneof, check if it has already been set.
-			if od := fd.ContainingOneof(); od != nil {
-				idx := uint64(od.Index())
-				if seenOneofs.Has(idx) {
-					return d.newError(tok.Pos(), "error parsing %q, oneof %v is already set", tok.RawString(), od.FullName())
-				}
-				seenOneofs.Set(idx)
-			}
-
-			num := uint64(fd.Number())
-			if seenNums.Has(num) {
-				return d.newError(tok.Pos(), "non-repeated field %q is repeated", tok.RawString())
-			}
-
-			if err := d.unmarshalSingular(fd, m); err != nil {
-				return err
-			}
-			seenNums.Set(num)
-		}
-	}
-
-	return nil
-}
-
-// findExtension returns protoreflect.ExtensionType from the Resolver if found.
-func (d decoder) findExtension(xtName pref.FullName) (pref.ExtensionType, error) {
-	xt, err := d.opts.Resolver.FindExtensionByName(xtName)
-	if err == nil {
-		return xt, nil
-	}
-	return messageset.FindMessageSetExtension(d.opts.Resolver, xtName)
-}
-
-// unmarshalSingular unmarshals a non-repeated field value specified by the
-// given FieldDescriptor.
-func (d decoder) unmarshalSingular(fd pref.FieldDescriptor, m pref.Message) error {
-	var val pref.Value
-	var err error
-	switch fd.Kind() {
-	case pref.MessageKind, pref.GroupKind:
-		val = m.NewField(fd)
-		err = d.unmarshalMessage(val.Message(), true)
-	default:
-		val, err = d.unmarshalScalar(fd)
-	}
-	if err == nil {
-		m.Set(fd, val)
-	}
-	return err
-}
-
-// unmarshalScalar unmarshals a scalar/enum protoreflect.Value specified by the
-// given FieldDescriptor.
-func (d decoder) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error) {
-	tok, err := d.Read()
-	if err != nil {
-		return pref.Value{}, err
-	}
-
-	if tok.Kind() != text.Scalar {
-		return pref.Value{}, d.unexpectedTokenError(tok)
-	}
-
-	kind := fd.Kind()
-	switch kind {
-	case pref.BoolKind:
-		if b, ok := tok.Bool(); ok {
-			return pref.ValueOfBool(b), nil
-		}
-
-	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
-		if n, ok := tok.Int32(); ok {
-			return pref.ValueOfInt32(n), nil
-		}
-
-	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-		if n, ok := tok.Int64(); ok {
-			return pref.ValueOfInt64(n), nil
-		}
-
-	case pref.Uint32Kind, pref.Fixed32Kind:
-		if n, ok := tok.Uint32(); ok {
-			return pref.ValueOfUint32(n), nil
-		}
-
-	case pref.Uint64Kind, pref.Fixed64Kind:
-		if n, ok := tok.Uint64(); ok {
-			return pref.ValueOfUint64(n), nil
-		}
-
-	case pref.FloatKind:
-		if n, ok := tok.Float32(); ok {
-			return pref.ValueOfFloat32(n), nil
-		}
-
-	case pref.DoubleKind:
-		if n, ok := tok.Float64(); ok {
-			return pref.ValueOfFloat64(n), nil
-		}
-
-	case pref.StringKind:
-		if s, ok := tok.String(); ok {
-			if strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
-				return pref.Value{}, d.newError(tok.Pos(), "contains invalid UTF-8")
-			}
-			return pref.ValueOfString(s), nil
-		}
-
-	case pref.BytesKind:
-		if b, ok := tok.String(); ok {
-			return pref.ValueOfBytes([]byte(b)), nil
-		}
-
-	case pref.EnumKind:
-		if lit, ok := tok.Enum(); ok {
-			// Lookup EnumNumber based on name.
-			if enumVal := fd.Enum().Values().ByName(pref.Name(lit)); enumVal != nil {
-				return pref.ValueOfEnum(enumVal.Number()), nil
-			}
-		}
-		if num, ok := tok.Int32(); ok {
-			return pref.ValueOfEnum(pref.EnumNumber(num)), nil
-		}
-
-	default:
-		panic(fmt.Sprintf("invalid scalar kind %v", kind))
-	}
-
-	return pref.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
-}
-
-// unmarshalList unmarshals into given protoreflect.List. A list value can
-// either be in [] syntax or simply just a single scalar/message value.
-func (d decoder) unmarshalList(fd pref.FieldDescriptor, list pref.List) error {
-	tok, err := d.Peek()
-	if err != nil {
-		return err
-	}
-
-	switch fd.Kind() {
-	case pref.MessageKind, pref.GroupKind:
-		switch tok.Kind() {
-		case text.ListOpen:
-			d.Read()
-			for {
-				tok, err := d.Peek()
-				if err != nil {
-					return err
-				}
-
-				switch tok.Kind() {
-				case text.ListClose:
-					d.Read()
-					return nil
-				case text.MessageOpen:
-					pval := list.NewElement()
-					if err := d.unmarshalMessage(pval.Message(), true); err != nil {
-						return err
-					}
-					list.Append(pval)
-				default:
-					return d.unexpectedTokenError(tok)
-				}
-			}
-
-		case text.MessageOpen:
-			pval := list.NewElement()
-			if err := d.unmarshalMessage(pval.Message(), true); err != nil {
-				return err
-			}
-			list.Append(pval)
-			return nil
-		}
-
-	default:
-		switch tok.Kind() {
-		case text.ListOpen:
-			d.Read()
-			for {
-				tok, err := d.Peek()
-				if err != nil {
-					return err
-				}
-
-				switch tok.Kind() {
-				case text.ListClose:
-					d.Read()
-					return nil
-				case text.Scalar:
-					pval, err := d.unmarshalScalar(fd)
-					if err != nil {
-						return err
-					}
-					list.Append(pval)
-				default:
-					return d.unexpectedTokenError(tok)
-				}
-			}
-
-		case text.Scalar:
-			pval, err := d.unmarshalScalar(fd)
-			if err != nil {
-				return err
-			}
-			list.Append(pval)
-			return nil
-		}
-	}
-
-	return d.unexpectedTokenError(tok)
-}
-
-// unmarshalMap unmarshals into given protoreflect.Map. A map value is a
-// textproto message containing {key: <kvalue>, value: <mvalue>}.
-func (d decoder) unmarshalMap(fd pref.FieldDescriptor, mmap pref.Map) error {
-	// Determine ahead whether map entry is a scalar type or a message type in
-	// order to call the appropriate unmarshalMapValue func inside
-	// unmarshalMapEntry.
-	var unmarshalMapValue func() (pref.Value, error)
-	switch fd.MapValue().Kind() {
-	case pref.MessageKind, pref.GroupKind:
-		unmarshalMapValue = func() (pref.Value, error) {
-			pval := mmap.NewValue()
-			if err := d.unmarshalMessage(pval.Message(), true); err != nil {
-				return pref.Value{}, err
-			}
-			return pval, nil
-		}
-	default:
-		unmarshalMapValue = func() (pref.Value, error) {
-			return d.unmarshalScalar(fd.MapValue())
-		}
-	}
-
-	tok, err := d.Read()
-	if err != nil {
-		return err
-	}
-	switch tok.Kind() {
-	case text.MessageOpen:
-		return d.unmarshalMapEntry(fd, mmap, unmarshalMapValue)
-
-	case text.ListOpen:
-		for {
-			tok, err := d.Read()
-			if err != nil {
-				return err
-			}
-			switch tok.Kind() {
-			case text.ListClose:
-				return nil
-			case text.MessageOpen:
-				if err := d.unmarshalMapEntry(fd, mmap, unmarshalMapValue); err != nil {
-					return err
-				}
-			default:
-				return d.unexpectedTokenError(tok)
-			}
-		}
-
-	default:
-		return d.unexpectedTokenError(tok)
-	}
-}
-
-// unmarshalMap unmarshals into given protoreflect.Map. A map value is a
-// textproto message containing {key: <kvalue>, value: <mvalue>}.
-func (d decoder) unmarshalMapEntry(fd pref.FieldDescriptor, mmap pref.Map, unmarshalMapValue func() (pref.Value, error)) error {
-	var key pref.MapKey
-	var pval pref.Value
-Loop:
-	for {
-		// Read field name.
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		switch tok.Kind() {
-		case text.Name:
-			if tok.NameKind() != text.IdentName {
-				if !d.opts.DiscardUnknown {
-					return d.newError(tok.Pos(), "unknown map entry field %q", tok.RawString())
-				}
-				d.skipValue()
-				continue Loop
-			}
-			// Continue below.
-		case text.MessageClose:
-			break Loop
-		default:
-			return d.unexpectedTokenError(tok)
-		}
-
-		name := tok.IdentName()
-		switch name {
-		case "key":
-			if !tok.HasSeparator() {
-				return d.syntaxError(tok.Pos(), "missing field separator :")
-			}
-			if key.IsValid() {
-				return d.newError(tok.Pos(), `map entry "key" cannot be repeated`)
-			}
-			val, err := d.unmarshalScalar(fd.MapKey())
-			if err != nil {
-				return err
-			}
-			key = val.MapKey()
-
-		case "value":
-			if kind := fd.MapValue().Kind(); (kind != pref.MessageKind) && (kind != pref.GroupKind) {
-				if !tok.HasSeparator() {
-					return d.syntaxError(tok.Pos(), "missing field separator :")
-				}
-			}
-			if pval.IsValid() {
-				return d.newError(tok.Pos(), `map entry "value" cannot be repeated`)
-			}
-			pval, err = unmarshalMapValue()
-			if err != nil {
-				return err
-			}
-
-		default:
-			if !d.opts.DiscardUnknown {
-				return d.newError(tok.Pos(), "unknown map entry field %q", name)
-			}
-			d.skipValue()
-		}
-	}
-
-	if !key.IsValid() {
-		key = fd.MapKey().Default().MapKey()
-	}
-	if !pval.IsValid() {
-		switch fd.MapValue().Kind() {
-		case pref.MessageKind, pref.GroupKind:
-			// If value field is not set for message/group types, construct an
-			// empty one as default.
-			pval = mmap.NewValue()
-		default:
-			pval = fd.MapValue().Default()
-		}
-	}
-	mmap.Set(key, pval)
-	return nil
-}
-
-// unmarshalAny unmarshals an Any textproto. It can either be in expanded form
-// or non-expanded form.
-func (d decoder) unmarshalAny(m pref.Message, checkDelims bool) error {
-	var typeURL string
-	var bValue []byte
-
-	// hasFields tracks which valid fields have been seen in the loop below in
-	// order to flag an error if there are duplicates or conflicts. It may
-	// contain the strings "type_url", "value" and "expanded".  The literal
-	// "expanded" is used to indicate that the expanded form has been
-	// encountered already.
-	hasFields := map[string]bool{}
-
-	if checkDelims {
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-
-		if tok.Kind() != text.MessageOpen {
-			return d.unexpectedTokenError(tok)
-		}
-	}
-
-Loop:
-	for {
-		// Read field name. Can only have 3 possible field names, i.e. type_url,
-		// value and type URL name inside [].
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		if typ := tok.Kind(); typ != text.Name {
-			if checkDelims {
-				if typ == text.MessageClose {
-					break Loop
-				}
-			} else if typ == text.EOF {
-				break Loop
-			}
-			return d.unexpectedTokenError(tok)
-		}
-
-		switch tok.NameKind() {
-		case text.IdentName:
-			// Both type_url and value fields require field separator :.
-			if !tok.HasSeparator() {
-				return d.syntaxError(tok.Pos(), "missing field separator :")
-			}
-
-			switch tok.IdentName() {
-			case "type_url":
-				if hasFields["type_url"] {
-					return d.newError(tok.Pos(), "duplicate Any type_url field")
-				}
-				if hasFields["expanded"] {
-					return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
-				}
-				tok, err := d.Read()
-				if err != nil {
-					return err
-				}
-				var ok bool
-				typeURL, ok = tok.String()
-				if !ok {
-					return d.newError(tok.Pos(), "invalid Any type_url: %v", tok.RawString())
-				}
-				hasFields["type_url"] = true
-
-			case "value":
-				if hasFields["value"] {
-					return d.newError(tok.Pos(), "duplicate Any value field")
-				}
-				if hasFields["expanded"] {
-					return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
-				}
-				tok, err := d.Read()
-				if err != nil {
-					return err
-				}
-				s, ok := tok.String()
-				if !ok {
-					return d.newError(tok.Pos(), "invalid Any value: %v", tok.RawString())
-				}
-				bValue = []byte(s)
-				hasFields["value"] = true
-
-			default:
-				if !d.opts.DiscardUnknown {
-					return d.newError(tok.Pos(), "invalid field name %q in google.protobuf.Any message", tok.RawString())
-				}
-			}
-
-		case text.TypeName:
-			if hasFields["expanded"] {
-				return d.newError(tok.Pos(), "cannot have more than one type")
-			}
-			if hasFields["type_url"] {
-				return d.newError(tok.Pos(), "conflict with type_url field")
-			}
-			typeURL = tok.TypeName()
-			var err error
-			bValue, err = d.unmarshalExpandedAny(typeURL, tok.Pos())
-			if err != nil {
-				return err
-			}
-			hasFields["expanded"] = true
-
-		default:
-			if !d.opts.DiscardUnknown {
-				return d.newError(tok.Pos(), "invalid field name %q in google.protobuf.Any message", tok.RawString())
-			}
-		}
-	}
-
-	fds := m.Descriptor().Fields()
-	if len(typeURL) > 0 {
-		m.Set(fds.ByNumber(fieldnum.Any_TypeUrl), pref.ValueOfString(typeURL))
-	}
-	if len(bValue) > 0 {
-		m.Set(fds.ByNumber(fieldnum.Any_Value), pref.ValueOfBytes(bValue))
-	}
-	return nil
-}
-
-func (d decoder) unmarshalExpandedAny(typeURL string, pos int) ([]byte, error) {
-	mt, err := d.opts.Resolver.FindMessageByURL(typeURL)
-	if err != nil {
-		return nil, d.newError(pos, "unable to resolve message [%v]: %v", typeURL, err)
-	}
-	// Create new message for the embedded message type and unmarshal the value
-	// field into it.
-	m := mt.New()
-	if err := d.unmarshalMessage(m, true); err != nil {
-		return nil, err
-	}
-	// Serialize the embedded message and return the resulting bytes.
-	b, err := proto.MarshalOptions{
-		AllowPartial:  true, // Never check required fields inside an Any.
-		Deterministic: true,
-	}.Marshal(m.Interface())
-	if err != nil {
-		return nil, d.newError(pos, "error in marshaling message into Any.value: %v", err)
-	}
-	return b, nil
-}
-
-// skipValue makes the decoder parse a field value in order to advance the read
-// to the next field. It relies on Read returning an error if the types are not
-// in valid sequence.
-func (d decoder) skipValue() error {
-	tok, err := d.Read()
-	if err != nil {
-		return err
-	}
-	// Only need to continue reading for messages and lists.
-	switch tok.Kind() {
-	case text.MessageOpen:
-		return d.skipMessageValue()
-
-	case text.ListOpen:
-		for {
-			tok, err := d.Read()
-			if err != nil {
-				return err
-			}
-			switch tok.Kind() {
-			case text.ListClose:
-				return nil
-			case text.MessageOpen:
-				return d.skipMessageValue()
-			default:
-				// Skip items. This will not validate whether skipped values are
-				// of the same type or not, same behavior as C++
-				// TextFormat::Parser::AllowUnknownField(true) version 3.8.0.
-				if err := d.skipValue(); err != nil {
-					return err
-				}
-			}
-		}
-	}
-	return nil
-}
-
-// skipMessageValue makes the decoder parse and skip over all fields in a
-// message. It assumes that the previous read type is MessageOpen.
-func (d decoder) skipMessageValue() error {
-	for {
-		tok, err := d.Read()
-		if err != nil {
-			return err
-		}
-		switch tok.Kind() {
-		case text.MessageClose:
-			return nil
-		case text.Name:
-			if err := d.skipValue(); err != nil {
-				return err
-			}
-		}
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/doc.go b/vendor/google.golang.org/protobuf/encoding/prototext/doc.go
deleted file mode 100644
index 162b4f9..0000000
--- a/vendor/google.golang.org/protobuf/encoding/prototext/doc.go
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package prototext marshals and unmarshals protocol buffer messages as the
-// textproto format.
-package prototext
diff --git a/vendor/google.golang.org/protobuf/encoding/prototext/encode.go b/vendor/google.golang.org/protobuf/encoding/prototext/encode.go
deleted file mode 100644
index dece229..0000000
--- a/vendor/google.golang.org/protobuf/encoding/prototext/encode.go
+++ /dev/null
@@ -1,426 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package prototext
-
-import (
-	"fmt"
-	"sort"
-	"strconv"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/encoding/text"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/fieldnum"
-	"google.golang.org/protobuf/internal/flags"
-	"google.golang.org/protobuf/internal/mapsort"
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/internal/strs"
-	"google.golang.org/protobuf/proto"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-const defaultIndent = "  "
-
-// Format formats the message as a multiline string.
-// This function is only intended for human consumption and ignores errors.
-// Do not depend on the output being stable. It may change over time across
-// different versions of the program.
-func Format(m proto.Message) string {
-	return MarshalOptions{Multiline: true}.Format(m)
-}
-
-// Marshal writes the given proto.Message in textproto format using default
-// options. Do not depend on the output being stable. It may change over time
-// across different versions of the program.
-func Marshal(m proto.Message) ([]byte, error) {
-	return MarshalOptions{}.Marshal(m)
-}
-
-// MarshalOptions is a configurable text format marshaler.
-type MarshalOptions struct {
-	pragma.NoUnkeyedLiterals
-
-	// Multiline specifies whether the marshaler should format the output in
-	// indented-form with every textual element on a new line.
-	// If Indent is an empty string, then an arbitrary indent is chosen.
-	Multiline bool
-
-	// Indent specifies the set of indentation characters to use in a multiline
-	// formatted output such that every entry is preceded by Indent and
-	// terminated by a newline. If non-empty, then Multiline is treated as true.
-	// Indent can only be composed of space or tab characters.
-	Indent string
-
-	// EmitASCII specifies whether to format strings and bytes as ASCII only
-	// as opposed to using UTF-8 encoding when possible.
-	EmitASCII bool
-
-	// allowInvalidUTF8 specifies whether to permit the encoding of strings
-	// with invalid UTF-8. This is unexported as it is intended to only
-	// be specified by the Format method.
-	allowInvalidUTF8 bool
-
-	// AllowPartial allows messages that have missing required fields to marshal
-	// without returning an error. If AllowPartial is false (the default),
-	// Marshal will return error if there are any missing required fields.
-	AllowPartial bool
-
-	// EmitUnknown specifies whether to emit unknown fields in the output.
-	// If specified, the unmarshaler may be unable to parse the output.
-	// The default is to exclude unknown fields.
-	EmitUnknown bool
-
-	// Resolver is used for looking up types when expanding google.protobuf.Any
-	// messages. If nil, this defaults to using protoregistry.GlobalTypes.
-	Resolver interface {
-		protoregistry.ExtensionTypeResolver
-		protoregistry.MessageTypeResolver
-	}
-}
-
-// Format formats the message as a string.
-// This method is only intended for human consumption and ignores errors.
-// Do not depend on the output being stable. It may change over time across
-// different versions of the program.
-func (o MarshalOptions) Format(m proto.Message) string {
-	if m == nil || !m.ProtoReflect().IsValid() {
-		return "<nil>" // invalid syntax, but okay since this is for debugging
-	}
-	o.allowInvalidUTF8 = true
-	o.AllowPartial = true
-	o.EmitUnknown = true
-	b, _ := o.Marshal(m)
-	return string(b)
-}
-
-// Marshal writes the given proto.Message in textproto format using options in
-// MarshalOptions object. Do not depend on the output being stable. It may
-// change over time across different versions of the program.
-func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
-	var delims = [2]byte{'{', '}'}
-
-	if o.Multiline && o.Indent == "" {
-		o.Indent = defaultIndent
-	}
-	if o.Resolver == nil {
-		o.Resolver = protoregistry.GlobalTypes
-	}
-
-	internalEnc, err := text.NewEncoder(o.Indent, delims, o.EmitASCII)
-	if err != nil {
-		return nil, err
-	}
-
-	// Treat nil message interface as an empty message,
-	// in which case there is nothing to output.
-	if m == nil {
-		return []byte{}, nil
-	}
-
-	enc := encoder{internalEnc, o}
-	err = enc.marshalMessage(m.ProtoReflect(), false)
-	if err != nil {
-		return nil, err
-	}
-	out := enc.Bytes()
-	if len(o.Indent) > 0 && len(out) > 0 {
-		out = append(out, '\n')
-	}
-	if o.AllowPartial {
-		return out, nil
-	}
-	return out, proto.CheckInitialized(m)
-}
-
-type encoder struct {
-	*text.Encoder
-	opts MarshalOptions
-}
-
-// marshalMessage marshals the given protoreflect.Message.
-func (e encoder) marshalMessage(m pref.Message, inclDelims bool) error {
-	messageDesc := m.Descriptor()
-	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
-		return errors.New("no support for proto1 MessageSets")
-	}
-
-	if inclDelims {
-		e.StartMessage()
-		defer e.EndMessage()
-	}
-
-	// Handle Any expansion.
-	if messageDesc.FullName() == "google.protobuf.Any" {
-		if e.marshalAny(m) {
-			return nil
-		}
-		// If unable to expand, continue on to marshal Any as a regular message.
-	}
-
-	// Marshal known fields.
-	fieldDescs := messageDesc.Fields()
-	size := fieldDescs.Len()
-	for i := 0; i < size; {
-		fd := fieldDescs.Get(i)
-		if od := fd.ContainingOneof(); od != nil {
-			fd = m.WhichOneof(od)
-			i += od.Fields().Len()
-		} else {
-			i++
-		}
-
-		if fd == nil || !m.Has(fd) {
-			continue
-		}
-
-		name := fd.Name()
-		// Use type name for group field name.
-		if fd.Kind() == pref.GroupKind {
-			name = fd.Message().Name()
-		}
-		val := m.Get(fd)
-		if err := e.marshalField(string(name), val, fd); err != nil {
-			return err
-		}
-	}
-
-	// Marshal extensions.
-	if err := e.marshalExtensions(m); err != nil {
-		return err
-	}
-
-	// Marshal unknown fields.
-	if e.opts.EmitUnknown {
-		e.marshalUnknown(m.GetUnknown())
-	}
-
-	return nil
-}
-
-// marshalField marshals the given field with protoreflect.Value.
-func (e encoder) marshalField(name string, val pref.Value, fd pref.FieldDescriptor) error {
-	switch {
-	case fd.IsList():
-		return e.marshalList(name, val.List(), fd)
-	case fd.IsMap():
-		return e.marshalMap(name, val.Map(), fd)
-	default:
-		e.WriteName(name)
-		return e.marshalSingular(val, fd)
-	}
-}
-
-// marshalSingular marshals the given non-repeated field value. This includes
-// all scalar types, enums, messages, and groups.
-func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error {
-	kind := fd.Kind()
-	switch kind {
-	case pref.BoolKind:
-		e.WriteBool(val.Bool())
-
-	case pref.StringKind:
-		s := val.String()
-		if !e.opts.allowInvalidUTF8 && strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
-			return errors.InvalidUTF8(string(fd.FullName()))
-		}
-		e.WriteString(s)
-
-	case pref.Int32Kind, pref.Int64Kind,
-		pref.Sint32Kind, pref.Sint64Kind,
-		pref.Sfixed32Kind, pref.Sfixed64Kind:
-		e.WriteInt(val.Int())
-
-	case pref.Uint32Kind, pref.Uint64Kind,
-		pref.Fixed32Kind, pref.Fixed64Kind:
-		e.WriteUint(val.Uint())
-
-	case pref.FloatKind:
-		// Encoder.WriteFloat handles the special numbers NaN and infinites.
-		e.WriteFloat(val.Float(), 32)
-
-	case pref.DoubleKind:
-		// Encoder.WriteFloat handles the special numbers NaN and infinites.
-		e.WriteFloat(val.Float(), 64)
-
-	case pref.BytesKind:
-		e.WriteString(string(val.Bytes()))
-
-	case pref.EnumKind:
-		num := val.Enum()
-		if desc := fd.Enum().Values().ByNumber(num); desc != nil {
-			e.WriteLiteral(string(desc.Name()))
-		} else {
-			// Use numeric value if there is no enum description.
-			e.WriteInt(int64(num))
-		}
-
-	case pref.MessageKind, pref.GroupKind:
-		return e.marshalMessage(val.Message(), true)
-
-	default:
-		panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
-	}
-	return nil
-}
-
-// marshalList marshals the given protoreflect.List as multiple name-value fields.
-func (e encoder) marshalList(name string, list pref.List, fd pref.FieldDescriptor) error {
-	size := list.Len()
-	for i := 0; i < size; i++ {
-		e.WriteName(name)
-		if err := e.marshalSingular(list.Get(i), fd); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// marshalMap marshals the given protoreflect.Map as multiple name-value fields.
-func (e encoder) marshalMap(name string, mmap pref.Map, fd pref.FieldDescriptor) error {
-	var err error
-	mapsort.Range(mmap, fd.MapKey().Kind(), func(key pref.MapKey, val pref.Value) bool {
-		e.WriteName(name)
-		e.StartMessage()
-		defer e.EndMessage()
-
-		e.WriteName("key")
-		err = e.marshalSingular(key.Value(), fd.MapKey())
-		if err != nil {
-			return false
-		}
-
-		e.WriteName("value")
-		err = e.marshalSingular(val, fd.MapValue())
-		if err != nil {
-			return false
-		}
-		return true
-	})
-	return err
-}
-
-// marshalExtensions marshals extension fields.
-func (e encoder) marshalExtensions(m pref.Message) error {
-	type entry struct {
-		key   string
-		value pref.Value
-		desc  pref.FieldDescriptor
-	}
-
-	// Get a sorted list based on field key first.
-	var entries []entry
-	m.Range(func(fd pref.FieldDescriptor, v pref.Value) bool {
-		if !fd.IsExtension() {
-			return true
-		}
-		// For MessageSet extensions, the name used is the parent message.
-		name := fd.FullName()
-		if messageset.IsMessageSetExtension(fd) {
-			name = name.Parent()
-		}
-		entries = append(entries, entry{
-			key:   string(name),
-			value: v,
-			desc:  fd,
-		})
-		return true
-	})
-	// Sort extensions lexicographically.
-	sort.Slice(entries, func(i, j int) bool {
-		return entries[i].key < entries[j].key
-	})
-
-	// Write out sorted list.
-	for _, entry := range entries {
-		// Extension field name is the proto field name enclosed in [].
-		name := "[" + entry.key + "]"
-		if err := e.marshalField(name, entry.value, entry.desc); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// marshalUnknown parses the given []byte and marshals fields out.
-// This function assumes proper encoding in the given []byte.
-func (e encoder) marshalUnknown(b []byte) {
-	const dec = 10
-	const hex = 16
-	for len(b) > 0 {
-		num, wtype, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		e.WriteName(strconv.FormatInt(int64(num), dec))
-
-		switch wtype {
-		case protowire.VarintType:
-			var v uint64
-			v, n = protowire.ConsumeVarint(b)
-			e.WriteUint(v)
-		case protowire.Fixed32Type:
-			var v uint32
-			v, n = protowire.ConsumeFixed32(b)
-			e.WriteLiteral("0x" + strconv.FormatUint(uint64(v), hex))
-		case protowire.Fixed64Type:
-			var v uint64
-			v, n = protowire.ConsumeFixed64(b)
-			e.WriteLiteral("0x" + strconv.FormatUint(v, hex))
-		case protowire.BytesType:
-			var v []byte
-			v, n = protowire.ConsumeBytes(b)
-			e.WriteString(string(v))
-		case protowire.StartGroupType:
-			e.StartMessage()
-			var v []byte
-			v, n = protowire.ConsumeGroup(num, b)
-			e.marshalUnknown(v)
-			e.EndMessage()
-		default:
-			panic(fmt.Sprintf("prototext: error parsing unknown field wire type: %v", wtype))
-		}
-
-		b = b[n:]
-	}
-}
-
-// marshalAny marshals the given google.protobuf.Any message in expanded form.
-// It returns true if it was able to marshal, else false.
-func (e encoder) marshalAny(any pref.Message) bool {
-	// Construct the embedded message.
-	fds := any.Descriptor().Fields()
-	fdType := fds.ByNumber(fieldnum.Any_TypeUrl)
-	typeURL := any.Get(fdType).String()
-	mt, err := e.opts.Resolver.FindMessageByURL(typeURL)
-	if err != nil {
-		return false
-	}
-	m := mt.New().Interface()
-
-	// Unmarshal bytes into embedded message.
-	fdValue := fds.ByNumber(fieldnum.Any_Value)
-	value := any.Get(fdValue)
-	err = proto.UnmarshalOptions{
-		AllowPartial: true,
-		Resolver:     e.opts.Resolver,
-	}.Unmarshal(value.Bytes(), m)
-	if err != nil {
-		return false
-	}
-
-	// Get current encoder position. If marshaling fails, reset encoder output
-	// back to this position.
-	pos := e.Snapshot()
-
-	// Field name is the proto field name enclosed in [].
-	e.WriteName("[" + typeURL + "]")
-	err = e.marshalMessage(m.ProtoReflect(), true)
-	if err != nil {
-		e.Reset(pos)
-		return false
-	}
-	return true
-}
diff --git a/vendor/google.golang.org/protobuf/encoding/protowire/wire.go b/vendor/google.golang.org/protobuf/encoding/protowire/wire.go
deleted file mode 100644
index a427f8b..0000000
--- a/vendor/google.golang.org/protobuf/encoding/protowire/wire.go
+++ /dev/null
@@ -1,538 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protowire parses and formats the raw wire encoding.
-// See https://developers.google.com/protocol-buffers/docs/encoding.
-//
-// For marshaling and unmarshaling entire protobuf messages,
-// use the "google.golang.org/protobuf/proto" package instead.
-package protowire
-
-import (
-	"io"
-	"math"
-	"math/bits"
-
-	"google.golang.org/protobuf/internal/errors"
-)
-
-// Number represents the field number.
-type Number int32
-
-const (
-	MinValidNumber      Number = 1
-	FirstReservedNumber Number = 19000
-	LastReservedNumber  Number = 19999
-	MaxValidNumber      Number = 1<<29 - 1
-)
-
-// IsValid reports whether the field number is semantically valid.
-//
-// Note that while numbers within the reserved range are semantically invalid,
-// they are syntactically valid in the wire format.
-// Implementations may treat records with reserved field numbers as unknown.
-func (n Number) IsValid() bool {
-	return MinValidNumber <= n && n < FirstReservedNumber || LastReservedNumber < n && n <= MaxValidNumber
-}
-
-// Type represents the wire type.
-type Type int8
-
-const (
-	VarintType     Type = 0
-	Fixed32Type    Type = 5
-	Fixed64Type    Type = 1
-	BytesType      Type = 2
-	StartGroupType Type = 3
-	EndGroupType   Type = 4
-)
-
-const (
-	_ = -iota
-	errCodeTruncated
-	errCodeFieldNumber
-	errCodeOverflow
-	errCodeReserved
-	errCodeEndGroup
-)
-
-var (
-	errFieldNumber = errors.New("invalid field number")
-	errOverflow    = errors.New("variable length integer overflow")
-	errReserved    = errors.New("cannot parse reserved wire type")
-	errEndGroup    = errors.New("mismatching end group marker")
-	errParse       = errors.New("parse error")
-)
-
-// ParseError converts an error code into an error value.
-// This returns nil if n is a non-negative number.
-func ParseError(n int) error {
-	if n >= 0 {
-		return nil
-	}
-	switch n {
-	case errCodeTruncated:
-		return io.ErrUnexpectedEOF
-	case errCodeFieldNumber:
-		return errFieldNumber
-	case errCodeOverflow:
-		return errOverflow
-	case errCodeReserved:
-		return errReserved
-	case errCodeEndGroup:
-		return errEndGroup
-	default:
-		return errParse
-	}
-}
-
-// ConsumeField parses an entire field record (both tag and value) and returns
-// the field number, the wire type, and the total length.
-// This returns a negative length upon an error (see ParseError).
-//
-// The total length includes the tag header and the end group marker (if the
-// field is a group).
-func ConsumeField(b []byte) (Number, Type, int) {
-	num, typ, n := ConsumeTag(b)
-	if n < 0 {
-		return 0, 0, n // forward error code
-	}
-	m := ConsumeFieldValue(num, typ, b[n:])
-	if m < 0 {
-		return 0, 0, m // forward error code
-	}
-	return num, typ, n + m
-}
-
-// ConsumeFieldValue parses a field value and returns its length.
-// This assumes that the field Number and wire Type have already been parsed.
-// This returns a negative length upon an error (see ParseError).
-//
-// When parsing a group, the length includes the end group marker and
-// the end group is verified to match the starting field number.
-func ConsumeFieldValue(num Number, typ Type, b []byte) (n int) {
-	switch typ {
-	case VarintType:
-		_, n = ConsumeVarint(b)
-		return n
-	case Fixed32Type:
-		_, n = ConsumeFixed32(b)
-		return n
-	case Fixed64Type:
-		_, n = ConsumeFixed64(b)
-		return n
-	case BytesType:
-		_, n = ConsumeBytes(b)
-		return n
-	case StartGroupType:
-		n0 := len(b)
-		for {
-			num2, typ2, n := ConsumeTag(b)
-			if n < 0 {
-				return n // forward error code
-			}
-			b = b[n:]
-			if typ2 == EndGroupType {
-				if num != num2 {
-					return errCodeEndGroup
-				}
-				return n0 - len(b)
-			}
-
-			n = ConsumeFieldValue(num2, typ2, b)
-			if n < 0 {
-				return n // forward error code
-			}
-			b = b[n:]
-		}
-	case EndGroupType:
-		return errCodeEndGroup
-	default:
-		return errCodeReserved
-	}
-}
-
-// AppendTag encodes num and typ as a varint-encoded tag and appends it to b.
-func AppendTag(b []byte, num Number, typ Type) []byte {
-	return AppendVarint(b, EncodeTag(num, typ))
-}
-
-// ConsumeTag parses b as a varint-encoded tag, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeTag(b []byte) (Number, Type, int) {
-	v, n := ConsumeVarint(b)
-	if n < 0 {
-		return 0, 0, n // forward error code
-	}
-	num, typ := DecodeTag(v)
-	if num < MinValidNumber {
-		return 0, 0, errCodeFieldNumber
-	}
-	return num, typ, n
-}
-
-func SizeTag(num Number) int {
-	return SizeVarint(EncodeTag(num, 0)) // wire type has no effect on size
-}
-
-// AppendVarint appends v to b as a varint-encoded uint64.
-func AppendVarint(b []byte, v uint64) []byte {
-	switch {
-	case v < 1<<7:
-		b = append(b, byte(v))
-	case v < 1<<14:
-		b = append(b,
-			byte((v>>0)&0x7f|0x80),
-			byte(v>>7))
-	case v < 1<<21:
-		b = append(b,
-			byte((v>>0)&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte(v>>14))
-	case v < 1<<28:
-		b = append(b,
-			byte((v>>0)&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte(v>>21))
-	case v < 1<<35:
-		b = append(b,
-			byte((v>>0)&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte(v>>28))
-	case v < 1<<42:
-		b = append(b,
-			byte((v>>0)&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte((v>>28)&0x7f|0x80),
-			byte(v>>35))
-	case v < 1<<49:
-		b = append(b,
-			byte((v>>0)&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte((v>>28)&0x7f|0x80),
-			byte((v>>35)&0x7f|0x80),
-			byte(v>>42))
-	case v < 1<<56:
-		b = append(b,
-			byte((v>>0)&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte((v>>28)&0x7f|0x80),
-			byte((v>>35)&0x7f|0x80),
-			byte((v>>42)&0x7f|0x80),
-			byte(v>>49))
-	case v < 1<<63:
-		b = append(b,
-			byte((v>>0)&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte((v>>28)&0x7f|0x80),
-			byte((v>>35)&0x7f|0x80),
-			byte((v>>42)&0x7f|0x80),
-			byte((v>>49)&0x7f|0x80),
-			byte(v>>56))
-	default:
-		b = append(b,
-			byte((v>>0)&0x7f|0x80),
-			byte((v>>7)&0x7f|0x80),
-			byte((v>>14)&0x7f|0x80),
-			byte((v>>21)&0x7f|0x80),
-			byte((v>>28)&0x7f|0x80),
-			byte((v>>35)&0x7f|0x80),
-			byte((v>>42)&0x7f|0x80),
-			byte((v>>49)&0x7f|0x80),
-			byte((v>>56)&0x7f|0x80),
-			1)
-	}
-	return b
-}
-
-// ConsumeVarint parses b as a varint-encoded uint64, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeVarint(b []byte) (v uint64, n int) {
-	var y uint64
-	if len(b) <= 0 {
-		return 0, errCodeTruncated
-	}
-	v = uint64(b[0])
-	if v < 0x80 {
-		return v, 1
-	}
-	v -= 0x80
-
-	if len(b) <= 1 {
-		return 0, errCodeTruncated
-	}
-	y = uint64(b[1])
-	v += y << 7
-	if y < 0x80 {
-		return v, 2
-	}
-	v -= 0x80 << 7
-
-	if len(b) <= 2 {
-		return 0, errCodeTruncated
-	}
-	y = uint64(b[2])
-	v += y << 14
-	if y < 0x80 {
-		return v, 3
-	}
-	v -= 0x80 << 14
-
-	if len(b) <= 3 {
-		return 0, errCodeTruncated
-	}
-	y = uint64(b[3])
-	v += y << 21
-	if y < 0x80 {
-		return v, 4
-	}
-	v -= 0x80 << 21
-
-	if len(b) <= 4 {
-		return 0, errCodeTruncated
-	}
-	y = uint64(b[4])
-	v += y << 28
-	if y < 0x80 {
-		return v, 5
-	}
-	v -= 0x80 << 28
-
-	if len(b) <= 5 {
-		return 0, errCodeTruncated
-	}
-	y = uint64(b[5])
-	v += y << 35
-	if y < 0x80 {
-		return v, 6
-	}
-	v -= 0x80 << 35
-
-	if len(b) <= 6 {
-		return 0, errCodeTruncated
-	}
-	y = uint64(b[6])
-	v += y << 42
-	if y < 0x80 {
-		return v, 7
-	}
-	v -= 0x80 << 42
-
-	if len(b) <= 7 {
-		return 0, errCodeTruncated
-	}
-	y = uint64(b[7])
-	v += y << 49
-	if y < 0x80 {
-		return v, 8
-	}
-	v -= 0x80 << 49
-
-	if len(b) <= 8 {
-		return 0, errCodeTruncated
-	}
-	y = uint64(b[8])
-	v += y << 56
-	if y < 0x80 {
-		return v, 9
-	}
-	v -= 0x80 << 56
-
-	if len(b) <= 9 {
-		return 0, errCodeTruncated
-	}
-	y = uint64(b[9])
-	v += y << 63
-	if y < 2 {
-		return v, 10
-	}
-	return 0, errCodeOverflow
-}
-
-// SizeVarint returns the encoded size of a varint.
-// The size is guaranteed to be within 1 and 10, inclusive.
-func SizeVarint(v uint64) int {
-	// This computes 1 + (bits.Len64(v)-1)/7.
-	// 9/64 is a good enough approximation of 1/7
-	return int(9*uint32(bits.Len64(v))+64) / 64
-}
-
-// AppendFixed32 appends v to b as a little-endian uint32.
-func AppendFixed32(b []byte, v uint32) []byte {
-	return append(b,
-		byte(v>>0),
-		byte(v>>8),
-		byte(v>>16),
-		byte(v>>24))
-}
-
-// ConsumeFixed32 parses b as a little-endian uint32, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeFixed32(b []byte) (v uint32, n int) {
-	if len(b) < 4 {
-		return 0, errCodeTruncated
-	}
-	v = uint32(b[0])<<0 | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
-	return v, 4
-}
-
-// SizeFixed32 returns the encoded size of a fixed32; which is always 4.
-func SizeFixed32() int {
-	return 4
-}
-
-// AppendFixed64 appends v to b as a little-endian uint64.
-func AppendFixed64(b []byte, v uint64) []byte {
-	return append(b,
-		byte(v>>0),
-		byte(v>>8),
-		byte(v>>16),
-		byte(v>>24),
-		byte(v>>32),
-		byte(v>>40),
-		byte(v>>48),
-		byte(v>>56))
-}
-
-// ConsumeFixed64 parses b as a little-endian uint64, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeFixed64(b []byte) (v uint64, n int) {
-	if len(b) < 8 {
-		return 0, errCodeTruncated
-	}
-	v = uint64(b[0])<<0 | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
-	return v, 8
-}
-
-// SizeFixed64 returns the encoded size of a fixed64; which is always 8.
-func SizeFixed64() int {
-	return 8
-}
-
-// AppendBytes appends v to b as a length-prefixed bytes value.
-func AppendBytes(b []byte, v []byte) []byte {
-	return append(AppendVarint(b, uint64(len(v))), v...)
-}
-
-// ConsumeBytes parses b as a length-prefixed bytes value, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeBytes(b []byte) (v []byte, n int) {
-	m, n := ConsumeVarint(b)
-	if n < 0 {
-		return nil, n // forward error code
-	}
-	if m > uint64(len(b[n:])) {
-		return nil, errCodeTruncated
-	}
-	return b[n:][:m], n + int(m)
-}
-
-// SizeBytes returns the encoded size of a length-prefixed bytes value,
-// given only the length.
-func SizeBytes(n int) int {
-	return SizeVarint(uint64(n)) + n
-}
-
-// AppendString appends v to b as a length-prefixed bytes value.
-func AppendString(b []byte, v string) []byte {
-	return append(AppendVarint(b, uint64(len(v))), v...)
-}
-
-// ConsumeString parses b as a length-prefixed bytes value, reporting its length.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeString(b []byte) (v string, n int) {
-	bb, n := ConsumeBytes(b)
-	return string(bb), n
-}
-
-// AppendGroup appends v to b as group value, with a trailing end group marker.
-// The value v must not contain the end marker.
-func AppendGroup(b []byte, num Number, v []byte) []byte {
-	return AppendVarint(append(b, v...), EncodeTag(num, EndGroupType))
-}
-
-// ConsumeGroup parses b as a group value until the trailing end group marker,
-// and verifies that the end marker matches the provided num. The value v
-// does not contain the end marker, while the length does contain the end marker.
-// This returns a negative length upon an error (see ParseError).
-func ConsumeGroup(num Number, b []byte) (v []byte, n int) {
-	n = ConsumeFieldValue(num, StartGroupType, b)
-	if n < 0 {
-		return nil, n // forward error code
-	}
-	b = b[:n]
-
-	// Truncate off end group marker, but need to handle denormalized varints.
-	// Assuming end marker is never 0 (which is always the case since
-	// EndGroupType is non-zero), we can truncate all trailing bytes where the
-	// lower 7 bits are all zero (implying that the varint is denormalized).
-	for len(b) > 0 && b[len(b)-1]&0x7f == 0 {
-		b = b[:len(b)-1]
-	}
-	b = b[:len(b)-SizeTag(num)]
-	return b, n
-}
-
-// SizeGroup returns the encoded size of a group, given only the length.
-func SizeGroup(num Number, n int) int {
-	return n + SizeTag(num)
-}
-
-// DecodeTag decodes the field Number and wire Type from its unified form.
-// The Number is -1 if the decoded field number overflows int32.
-// Other than overflow, this does not check for field number validity.
-func DecodeTag(x uint64) (Number, Type) {
-	// NOTE: MessageSet allows for larger field numbers than normal.
-	if x>>3 > uint64(math.MaxInt32) {
-		return -1, 0
-	}
-	return Number(x >> 3), Type(x & 7)
-}
-
-// EncodeTag encodes the field Number and wire Type into its unified form.
-func EncodeTag(num Number, typ Type) uint64 {
-	return uint64(num)<<3 | uint64(typ&7)
-}
-
-// DecodeZigZag decodes a zig-zag-encoded uint64 as an int64.
-//	Input:  {…,  5,  3,  1,  0,  2,  4,  6, …}
-//	Output: {…, -3, -2, -1,  0, +1, +2, +3, …}
-func DecodeZigZag(x uint64) int64 {
-	return int64(x>>1) ^ int64(x)<<63>>63
-}
-
-// EncodeZigZag encodes an int64 as a zig-zag-encoded uint64.
-//	Input:  {…, -3, -2, -1,  0, +1, +2, +3, …}
-//	Output: {…,  5,  3,  1,  0,  2,  4,  6, …}
-func EncodeZigZag(x int64) uint64 {
-	return uint64(x<<1) ^ uint64(x>>63)
-}
-
-// DecodeBool decodes a uint64 as a bool.
-//	Input:  {    0,    1,    2, …}
-//	Output: {false, true, true, …}
-func DecodeBool(x uint64) bool {
-	return x != 0
-}
-
-// EncodeBool encodes a bool as a uint64.
-//	Input:  {false, true}
-//	Output: {    0,    1}
-func EncodeBool(x bool) uint64 {
-	if x {
-		return 1
-	}
-	return 0
-}
diff --git a/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go b/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go
deleted file mode 100644
index e7af0fe..0000000
--- a/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go
+++ /dev/null
@@ -1,316 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package descfmt provides functionality to format descriptors.
-package descfmt
-
-import (
-	"fmt"
-	"io"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"google.golang.org/protobuf/internal/detrand"
-	"google.golang.org/protobuf/internal/pragma"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type list interface {
-	Len() int
-	pragma.DoNotImplement
-}
-
-func FormatList(s fmt.State, r rune, vs list) {
-	io.WriteString(s, formatListOpt(vs, true, r == 'v' && (s.Flag('+') || s.Flag('#'))))
-}
-func formatListOpt(vs list, isRoot, allowMulti bool) string {
-	start, end := "[", "]"
-	if isRoot {
-		var name string
-		switch vs.(type) {
-		case pref.Names:
-			name = "Names"
-		case pref.FieldNumbers:
-			name = "FieldNumbers"
-		case pref.FieldRanges:
-			name = "FieldRanges"
-		case pref.EnumRanges:
-			name = "EnumRanges"
-		case pref.FileImports:
-			name = "FileImports"
-		case pref.Descriptor:
-			name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s"
-		}
-		start, end = name+"{", "}"
-	}
-
-	var ss []string
-	switch vs := vs.(type) {
-	case pref.Names:
-		for i := 0; i < vs.Len(); i++ {
-			ss = append(ss, fmt.Sprint(vs.Get(i)))
-		}
-		return start + joinStrings(ss, false) + end
-	case pref.FieldNumbers:
-		for i := 0; i < vs.Len(); i++ {
-			ss = append(ss, fmt.Sprint(vs.Get(i)))
-		}
-		return start + joinStrings(ss, false) + end
-	case pref.FieldRanges:
-		for i := 0; i < vs.Len(); i++ {
-			r := vs.Get(i)
-			if r[0]+1 == r[1] {
-				ss = append(ss, fmt.Sprintf("%d", r[0]))
-			} else {
-				ss = append(ss, fmt.Sprintf("%d:%d", r[0], r[1])) // enum ranges are end exclusive
-			}
-		}
-		return start + joinStrings(ss, false) + end
-	case pref.EnumRanges:
-		for i := 0; i < vs.Len(); i++ {
-			r := vs.Get(i)
-			if r[0] == r[1] {
-				ss = append(ss, fmt.Sprintf("%d", r[0]))
-			} else {
-				ss = append(ss, fmt.Sprintf("%d:%d", r[0], int64(r[1])+1)) // enum ranges are end inclusive
-			}
-		}
-		return start + joinStrings(ss, false) + end
-	case pref.FileImports:
-		for i := 0; i < vs.Len(); i++ {
-			var rs records
-			rs.Append(reflect.ValueOf(vs.Get(i)), "Path", "Package", "IsPublic", "IsWeak")
-			ss = append(ss, "{"+rs.Join()+"}")
-		}
-		return start + joinStrings(ss, allowMulti) + end
-	default:
-		_, isEnumValue := vs.(pref.EnumValueDescriptors)
-		for i := 0; i < vs.Len(); i++ {
-			m := reflect.ValueOf(vs).MethodByName("Get")
-			v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
-			ss = append(ss, formatDescOpt(v.(pref.Descriptor), false, allowMulti && !isEnumValue))
-		}
-		return start + joinStrings(ss, allowMulti && isEnumValue) + end
-	}
-}
-
-// descriptorAccessors is a list of accessors to print for each descriptor.
-//
-// Do not print all accessors since some contain redundant information,
-// while others are pointers that we do not want to follow since the descriptor
-// is actually a cyclic graph.
-//
-// Using a list allows us to print the accessors in a sensible order.
-var descriptorAccessors = map[reflect.Type][]string{
-	reflect.TypeOf((*pref.FileDescriptor)(nil)).Elem():      {"Path", "Package", "Imports", "Messages", "Enums", "Extensions", "Services"},
-	reflect.TypeOf((*pref.MessageDescriptor)(nil)).Elem():   {"IsMapEntry", "Fields", "Oneofs", "ReservedNames", "ReservedRanges", "RequiredNumbers", "ExtensionRanges", "Messages", "Enums", "Extensions"},
-	reflect.TypeOf((*pref.FieldDescriptor)(nil)).Elem():     {"Number", "Cardinality", "Kind", "HasJSONName", "JSONName", "HasPresence", "IsExtension", "IsPacked", "IsWeak", "IsList", "IsMap", "MapKey", "MapValue", "HasDefault", "Default", "ContainingOneof", "ContainingMessage", "Message", "Enum"},
-	reflect.TypeOf((*pref.OneofDescriptor)(nil)).Elem():     {"Fields"}, // not directly used; must keep in sync with formatDescOpt
-	reflect.TypeOf((*pref.EnumDescriptor)(nil)).Elem():      {"Values", "ReservedNames", "ReservedRanges"},
-	reflect.TypeOf((*pref.EnumValueDescriptor)(nil)).Elem(): {"Number"},
-	reflect.TypeOf((*pref.ServiceDescriptor)(nil)).Elem():   {"Methods"},
-	reflect.TypeOf((*pref.MethodDescriptor)(nil)).Elem():    {"Input", "Output", "IsStreamingClient", "IsStreamingServer"},
-}
-
-func FormatDesc(s fmt.State, r rune, t pref.Descriptor) {
-	io.WriteString(s, formatDescOpt(t, true, r == 'v' && (s.Flag('+') || s.Flag('#'))))
-}
-func formatDescOpt(t pref.Descriptor, isRoot, allowMulti bool) string {
-	rv := reflect.ValueOf(t)
-	rt := rv.MethodByName("ProtoType").Type().In(0)
-
-	start, end := "{", "}"
-	if isRoot {
-		start = rt.Name() + "{"
-	}
-
-	_, isFile := t.(pref.FileDescriptor)
-	rs := records{allowMulti: allowMulti}
-	if t.IsPlaceholder() {
-		if isFile {
-			rs.Append(rv, "Path", "Package", "IsPlaceholder")
-		} else {
-			rs.Append(rv, "FullName", "IsPlaceholder")
-		}
-	} else {
-		switch {
-		case isFile:
-			rs.Append(rv, "Syntax")
-		case isRoot:
-			rs.Append(rv, "Syntax", "FullName")
-		default:
-			rs.Append(rv, "Name")
-		}
-		switch t := t.(type) {
-		case pref.FieldDescriptor:
-			for _, s := range descriptorAccessors[rt] {
-				switch s {
-				case "MapKey":
-					if k := t.MapKey(); k != nil {
-						rs.recs = append(rs.recs, [2]string{"MapKey", k.Kind().String()})
-					}
-				case "MapValue":
-					if v := t.MapValue(); v != nil {
-						switch v.Kind() {
-						case pref.EnumKind:
-							rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Enum().FullName())})
-						case pref.MessageKind, pref.GroupKind:
-							rs.recs = append(rs.recs, [2]string{"MapValue", string(v.Message().FullName())})
-						default:
-							rs.recs = append(rs.recs, [2]string{"MapValue", v.Kind().String()})
-						}
-					}
-				case "ContainingOneof":
-					if od := t.ContainingOneof(); od != nil {
-						rs.recs = append(rs.recs, [2]string{"Oneof", string(od.Name())})
-					}
-				case "ContainingMessage":
-					if t.IsExtension() {
-						rs.recs = append(rs.recs, [2]string{"Extendee", string(t.ContainingMessage().FullName())})
-					}
-				case "Message":
-					if !t.IsMap() {
-						rs.Append(rv, s)
-					}
-				default:
-					rs.Append(rv, s)
-				}
-			}
-		case pref.OneofDescriptor:
-			var ss []string
-			fs := t.Fields()
-			for i := 0; i < fs.Len(); i++ {
-				ss = append(ss, string(fs.Get(i).Name()))
-			}
-			if len(ss) > 0 {
-				rs.recs = append(rs.recs, [2]string{"Fields", "[" + joinStrings(ss, false) + "]"})
-			}
-		default:
-			rs.Append(rv, descriptorAccessors[rt]...)
-		}
-		if rv.MethodByName("GoType").IsValid() {
-			rs.Append(rv, "GoType")
-		}
-	}
-	return start + rs.Join() + end
-}
-
-type records struct {
-	recs       [][2]string
-	allowMulti bool
-}
-
-func (rs *records) Append(v reflect.Value, accessors ...string) {
-	for _, a := range accessors {
-		var rv reflect.Value
-		if m := v.MethodByName(a); m.IsValid() {
-			rv = m.Call(nil)[0]
-		}
-		if v.Kind() == reflect.Struct && !rv.IsValid() {
-			rv = v.FieldByName(a)
-		}
-		if !rv.IsValid() {
-			panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a))
-		}
-		if _, ok := rv.Interface().(pref.Value); ok {
-			rv = rv.MethodByName("Interface").Call(nil)[0]
-			if !rv.IsNil() {
-				rv = rv.Elem()
-			}
-		}
-
-		// Ignore zero values.
-		var isZero bool
-		switch rv.Kind() {
-		case reflect.Interface, reflect.Slice:
-			isZero = rv.IsNil()
-		case reflect.Bool:
-			isZero = rv.Bool() == false
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			isZero = rv.Int() == 0
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			isZero = rv.Uint() == 0
-		case reflect.String:
-			isZero = rv.String() == ""
-		}
-		if n, ok := rv.Interface().(list); ok {
-			isZero = n.Len() == 0
-		}
-		if isZero {
-			continue
-		}
-
-		// Format the value.
-		var s string
-		v := rv.Interface()
-		switch v := v.(type) {
-		case list:
-			s = formatListOpt(v, false, rs.allowMulti)
-		case pref.FieldDescriptor, pref.OneofDescriptor, pref.EnumValueDescriptor, pref.MethodDescriptor:
-			s = string(v.(pref.Descriptor).Name())
-		case pref.Descriptor:
-			s = string(v.FullName())
-		case string:
-			s = strconv.Quote(v)
-		case []byte:
-			s = fmt.Sprintf("%q", v)
-		default:
-			s = fmt.Sprint(v)
-		}
-		rs.recs = append(rs.recs, [2]string{a, s})
-	}
-}
-
-func (rs *records) Join() string {
-	var ss []string
-
-	// In single line mode, simply join all records with commas.
-	if !rs.allowMulti {
-		for _, r := range rs.recs {
-			ss = append(ss, r[0]+formatColon(0)+r[1])
-		}
-		return joinStrings(ss, false)
-	}
-
-	// In allowMulti line mode, align single line records for more readable output.
-	var maxLen int
-	flush := func(i int) {
-		for _, r := range rs.recs[len(ss):i] {
-			ss = append(ss, r[0]+formatColon(maxLen-len(r[0]))+r[1])
-		}
-		maxLen = 0
-	}
-	for i, r := range rs.recs {
-		if isMulti := strings.Contains(r[1], "\n"); isMulti {
-			flush(i)
-			ss = append(ss, r[0]+formatColon(0)+strings.Join(strings.Split(r[1], "\n"), "\n\t"))
-		} else if maxLen < len(r[0]) {
-			maxLen = len(r[0])
-		}
-	}
-	flush(len(rs.recs))
-	return joinStrings(ss, true)
-}
-
-func formatColon(padding int) string {
-	// Deliberately introduce instability into the debug output to
-	// discourage users from performing string comparisons.
-	// This provides us flexibility to change the output in the future.
-	if detrand.Bool() {
-		return ":" + strings.Repeat(" ", 1+padding) // use non-breaking spaces (U+00a0)
-	} else {
-		return ":" + strings.Repeat(" ", 1+padding) // use regular spaces (U+0020)
-	}
-}
-
-func joinStrings(ss []string, isMulti bool) string {
-	if len(ss) == 0 {
-		return ""
-	}
-	if isMulti {
-		return "\n\t" + strings.Join(ss, "\n\t") + "\n"
-	}
-	return strings.Join(ss, ", ")
-}
diff --git a/vendor/google.golang.org/protobuf/internal/descopts/options.go b/vendor/google.golang.org/protobuf/internal/descopts/options.go
deleted file mode 100644
index 8401be8..0000000
--- a/vendor/google.golang.org/protobuf/internal/descopts/options.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package descopts contains the nil pointers to concrete descriptor options.
-//
-// This package exists as a form of reverse dependency injection so that certain
-// packages (e.g., internal/filedesc and internal/filetype can avoid a direct
-// dependency on the descriptor proto package).
-package descopts
-
-import pref "google.golang.org/protobuf/reflect/protoreflect"
-
-// These variables are set by the init function in descriptor.pb.go via logic
-// in internal/filetype. In other words, so long as the descriptor proto package
-// is linked in, these variables will be populated.
-//
-// Each variable is populated with a nil pointer to the options struct.
-var (
-	File           pref.ProtoMessage
-	Enum           pref.ProtoMessage
-	EnumValue      pref.ProtoMessage
-	Message        pref.ProtoMessage
-	Field          pref.ProtoMessage
-	Oneof          pref.ProtoMessage
-	ExtensionRange pref.ProtoMessage
-	Service        pref.ProtoMessage
-	Method         pref.ProtoMessage
-)
diff --git a/vendor/google.golang.org/protobuf/internal/detectknown/detect.go b/vendor/google.golang.org/protobuf/internal/detectknown/detect.go
deleted file mode 100644
index 091c423..0000000
--- a/vendor/google.golang.org/protobuf/internal/detectknown/detect.go
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package detectknown provides functionality for detecting well-known types
-// and identifying them by name.
-package detectknown
-
-import "google.golang.org/protobuf/reflect/protoreflect"
-
-type ProtoFile int
-
-const (
-	Unknown ProtoFile = iota
-	AnyProto
-	TimestampProto
-	DurationProto
-	WrappersProto
-	StructProto
-	FieldMaskProto
-	EmptyProto
-)
-
-var wellKnownTypes = map[protoreflect.FullName]ProtoFile{
-	"google.protobuf.Any":         AnyProto,
-	"google.protobuf.Timestamp":   TimestampProto,
-	"google.protobuf.Duration":    DurationProto,
-	"google.protobuf.BoolValue":   WrappersProto,
-	"google.protobuf.Int32Value":  WrappersProto,
-	"google.protobuf.Int64Value":  WrappersProto,
-	"google.protobuf.UInt32Value": WrappersProto,
-	"google.protobuf.UInt64Value": WrappersProto,
-	"google.protobuf.FloatValue":  WrappersProto,
-	"google.protobuf.DoubleValue": WrappersProto,
-	"google.protobuf.BytesValue":  WrappersProto,
-	"google.protobuf.StringValue": WrappersProto,
-	"google.protobuf.Struct":      StructProto,
-	"google.protobuf.ListValue":   StructProto,
-	"google.protobuf.Value":       StructProto,
-	"google.protobuf.FieldMask":   FieldMaskProto,
-	"google.protobuf.Empty":       EmptyProto,
-}
-
-// Which identifies the proto file that a well-known type belongs to.
-func Which(s protoreflect.FullName) ProtoFile {
-	return wellKnownTypes[s]
-}
diff --git a/vendor/google.golang.org/protobuf/internal/detrand/rand.go b/vendor/google.golang.org/protobuf/internal/detrand/rand.go
deleted file mode 100644
index a904dd1..0000000
--- a/vendor/google.golang.org/protobuf/internal/detrand/rand.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package detrand provides deterministically random functionality.
-//
-// The pseudo-randomness of these functions is seeded by the program binary
-// itself and guarantees that the output does not change within a program,
-// while ensuring that the output is unstable across different builds.
-package detrand
-
-import (
-	"encoding/binary"
-	"hash/fnv"
-	"os"
-)
-
-// Disable disables detrand such that all functions returns the zero value.
-// This function is not concurrent-safe and must be called during program init.
-func Disable() {
-	randSeed = 0
-}
-
-// Bool returns a deterministically random boolean.
-func Bool() bool {
-	return randSeed%2 == 1
-}
-
-// randSeed is a best-effort at an approximate hash of the Go binary.
-var randSeed = binaryHash()
-
-func binaryHash() uint64 {
-	// Open the Go binary.
-	s, err := os.Executable()
-	if err != nil {
-		return 0
-	}
-	f, err := os.Open(s)
-	if err != nil {
-		return 0
-	}
-	defer f.Close()
-
-	// Hash the size and several samples of the Go binary.
-	const numSamples = 8
-	var buf [64]byte
-	h := fnv.New64()
-	fi, err := f.Stat()
-	if err != nil {
-		return 0
-	}
-	binary.LittleEndian.PutUint64(buf[:8], uint64(fi.Size()))
-	h.Write(buf[:8])
-	for i := int64(0); i < numSamples; i++ {
-		if _, err := f.ReadAt(buf[:], i*fi.Size()/numSamples); err != nil {
-			return 0
-		}
-		h.Write(buf[:])
-	}
-	return h.Sum64()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/defval/default.go b/vendor/google.golang.org/protobuf/internal/encoding/defval/default.go
deleted file mode 100644
index fdd9b13..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/defval/default.go
+++ /dev/null
@@ -1,213 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package defval marshals and unmarshals textual forms of default values.
-//
-// This package handles both the form historically used in Go struct field tags
-// and also the form used by google.protobuf.FieldDescriptorProto.default_value
-// since they differ in superficial ways.
-package defval
-
-import (
-	"fmt"
-	"math"
-	"strconv"
-
-	ptext "google.golang.org/protobuf/internal/encoding/text"
-	errors "google.golang.org/protobuf/internal/errors"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Format is the serialization format used to represent the default value.
-type Format int
-
-const (
-	_ Format = iota
-
-	// Descriptor uses the serialization format that protoc uses with the
-	// google.protobuf.FieldDescriptorProto.default_value field.
-	Descriptor
-
-	// GoTag uses the historical serialization format in Go struct field tags.
-	GoTag
-)
-
-// Unmarshal deserializes the default string s according to the given kind k.
-// When k is an enum, a list of enum value descriptors must be provided.
-func Unmarshal(s string, k pref.Kind, evs pref.EnumValueDescriptors, f Format) (pref.Value, pref.EnumValueDescriptor, error) {
-	switch k {
-	case pref.BoolKind:
-		if f == GoTag {
-			switch s {
-			case "1":
-				return pref.ValueOfBool(true), nil, nil
-			case "0":
-				return pref.ValueOfBool(false), nil, nil
-			}
-		} else {
-			switch s {
-			case "true":
-				return pref.ValueOfBool(true), nil, nil
-			case "false":
-				return pref.ValueOfBool(false), nil, nil
-			}
-		}
-	case pref.EnumKind:
-		if f == GoTag {
-			// Go tags use the numeric form of the enum value.
-			if n, err := strconv.ParseInt(s, 10, 32); err == nil {
-				if ev := evs.ByNumber(pref.EnumNumber(n)); ev != nil {
-					return pref.ValueOfEnum(ev.Number()), ev, nil
-				}
-			}
-		} else {
-			// Descriptor default_value use the enum identifier.
-			ev := evs.ByName(pref.Name(s))
-			if ev != nil {
-				return pref.ValueOfEnum(ev.Number()), ev, nil
-			}
-		}
-	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
-		if v, err := strconv.ParseInt(s, 10, 32); err == nil {
-			return pref.ValueOfInt32(int32(v)), nil, nil
-		}
-	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-		if v, err := strconv.ParseInt(s, 10, 64); err == nil {
-			return pref.ValueOfInt64(int64(v)), nil, nil
-		}
-	case pref.Uint32Kind, pref.Fixed32Kind:
-		if v, err := strconv.ParseUint(s, 10, 32); err == nil {
-			return pref.ValueOfUint32(uint32(v)), nil, nil
-		}
-	case pref.Uint64Kind, pref.Fixed64Kind:
-		if v, err := strconv.ParseUint(s, 10, 64); err == nil {
-			return pref.ValueOfUint64(uint64(v)), nil, nil
-		}
-	case pref.FloatKind, pref.DoubleKind:
-		var v float64
-		var err error
-		switch s {
-		case "-inf":
-			v = math.Inf(-1)
-		case "inf":
-			v = math.Inf(+1)
-		case "nan":
-			v = math.NaN()
-		default:
-			v, err = strconv.ParseFloat(s, 64)
-		}
-		if err == nil {
-			if k == pref.FloatKind {
-				return pref.ValueOfFloat32(float32(v)), nil, nil
-			} else {
-				return pref.ValueOfFloat64(float64(v)), nil, nil
-			}
-		}
-	case pref.StringKind:
-		// String values are already unescaped and can be used as is.
-		return pref.ValueOfString(s), nil, nil
-	case pref.BytesKind:
-		if b, ok := unmarshalBytes(s); ok {
-			return pref.ValueOfBytes(b), nil, nil
-		}
-	}
-	return pref.Value{}, nil, errors.New("could not parse value for %v: %q", k, s)
-}
-
-// Marshal serializes v as the default string according to the given kind k.
-// When specifying the Descriptor format for an enum kind, the associated
-// enum value descriptor must be provided.
-func Marshal(v pref.Value, ev pref.EnumValueDescriptor, k pref.Kind, f Format) (string, error) {
-	switch k {
-	case pref.BoolKind:
-		if f == GoTag {
-			if v.Bool() {
-				return "1", nil
-			} else {
-				return "0", nil
-			}
-		} else {
-			if v.Bool() {
-				return "true", nil
-			} else {
-				return "false", nil
-			}
-		}
-	case pref.EnumKind:
-		if f == GoTag {
-			return strconv.FormatInt(int64(v.Enum()), 10), nil
-		} else {
-			return string(ev.Name()), nil
-		}
-	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind, pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-		return strconv.FormatInt(v.Int(), 10), nil
-	case pref.Uint32Kind, pref.Fixed32Kind, pref.Uint64Kind, pref.Fixed64Kind:
-		return strconv.FormatUint(v.Uint(), 10), nil
-	case pref.FloatKind, pref.DoubleKind:
-		f := v.Float()
-		switch {
-		case math.IsInf(f, -1):
-			return "-inf", nil
-		case math.IsInf(f, +1):
-			return "inf", nil
-		case math.IsNaN(f):
-			return "nan", nil
-		default:
-			if k == pref.FloatKind {
-				return strconv.FormatFloat(f, 'g', -1, 32), nil
-			} else {
-				return strconv.FormatFloat(f, 'g', -1, 64), nil
-			}
-		}
-	case pref.StringKind:
-		// String values are serialized as is without any escaping.
-		return v.String(), nil
-	case pref.BytesKind:
-		if s, ok := marshalBytes(v.Bytes()); ok {
-			return s, nil
-		}
-	}
-	return "", errors.New("could not format value for %v: %v", k, v)
-}
-
-// unmarshalBytes deserializes bytes by applying C unescaping.
-func unmarshalBytes(s string) ([]byte, bool) {
-	// Bytes values use the same escaping as the text format,
-	// however they lack the surrounding double quotes.
-	v, err := ptext.UnmarshalString(`"` + s + `"`)
-	if err != nil {
-		return nil, false
-	}
-	return []byte(v), true
-}
-
-// marshalBytes serializes bytes by using C escaping.
-// To match the exact output of protoc, this is identical to the
-// CEscape function in strutil.cc of the protoc source code.
-func marshalBytes(b []byte) (string, bool) {
-	var s []byte
-	for _, c := range b {
-		switch c {
-		case '\n':
-			s = append(s, `\n`...)
-		case '\r':
-			s = append(s, `\r`...)
-		case '\t':
-			s = append(s, `\t`...)
-		case '"':
-			s = append(s, `\"`...)
-		case '\'':
-			s = append(s, `\'`...)
-		case '\\':
-			s = append(s, `\\`...)
-		default:
-			if printableASCII := c >= 0x20 && c <= 0x7e; printableASCII {
-				s = append(s, c)
-			} else {
-				s = append(s, fmt.Sprintf(`\%03o`, c)...)
-			}
-		}
-	}
-	return string(s), true
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/decode.go b/vendor/google.golang.org/protobuf/internal/encoding/json/decode.go
deleted file mode 100644
index b13fd29..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/json/decode.go
+++ /dev/null
@@ -1,340 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"regexp"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/internal/errors"
-)
-
-// call specifies which Decoder method was invoked.
-type call uint8
-
-const (
-	readCall call = iota
-	peekCall
-)
-
-const unexpectedFmt = "unexpected token %s"
-
-// ErrUnexpectedEOF means that EOF was encountered in the middle of the input.
-var ErrUnexpectedEOF = errors.New("%v", io.ErrUnexpectedEOF)
-
-// Decoder is a token-based JSON decoder.
-type Decoder struct {
-	// lastCall is last method called, either readCall or peekCall.
-	// Initial value is readCall.
-	lastCall call
-
-	// lastToken contains the last read token.
-	lastToken Token
-
-	// lastErr contains the last read error.
-	lastErr error
-
-	// openStack is a stack containing ObjectOpen and ArrayOpen values. The
-	// top of stack represents the object or the array the current value is
-	// directly located in.
-	openStack []Kind
-
-	// orig is used in reporting line and column.
-	orig []byte
-	// in contains the unconsumed input.
-	in []byte
-}
-
-// NewDecoder returns a Decoder to read the given []byte.
-func NewDecoder(b []byte) *Decoder {
-	return &Decoder{orig: b, in: b}
-}
-
-// Peek looks ahead and returns the next token kind without advancing a read.
-func (d *Decoder) Peek() (Token, error) {
-	defer func() { d.lastCall = peekCall }()
-	if d.lastCall == readCall {
-		d.lastToken, d.lastErr = d.Read()
-	}
-	return d.lastToken, d.lastErr
-}
-
-// Read returns the next JSON token.
-// It will return an error if there is no valid token.
-func (d *Decoder) Read() (Token, error) {
-	const scalar = Null | Bool | Number | String
-
-	defer func() { d.lastCall = readCall }()
-	if d.lastCall == peekCall {
-		return d.lastToken, d.lastErr
-	}
-
-	tok, err := d.parseNext()
-	if err != nil {
-		return Token{}, err
-	}
-
-	switch tok.kind {
-	case EOF:
-		if len(d.openStack) != 0 ||
-			d.lastToken.kind&scalar|ObjectClose|ArrayClose == 0 {
-			return Token{}, ErrUnexpectedEOF
-		}
-
-	case Null:
-		if !d.isValueNext() {
-			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
-		}
-
-	case Bool, Number:
-		if !d.isValueNext() {
-			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
-		}
-
-	case String:
-		if d.isValueNext() {
-			break
-		}
-		// This string token should only be for a field name.
-		if d.lastToken.kind&(ObjectOpen|comma) == 0 {
-			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
-		}
-		if len(d.in) == 0 {
-			return Token{}, ErrUnexpectedEOF
-		}
-		if c := d.in[0]; c != ':' {
-			return Token{}, d.newSyntaxError(d.currPos(), `unexpected character %s, missing ":" after field name`, string(c))
-		}
-		tok.kind = Name
-		d.consume(1)
-
-	case ObjectOpen, ArrayOpen:
-		if !d.isValueNext() {
-			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
-		}
-		d.openStack = append(d.openStack, tok.kind)
-
-	case ObjectClose:
-		if len(d.openStack) == 0 ||
-			d.lastToken.kind == comma ||
-			d.openStack[len(d.openStack)-1] != ObjectOpen {
-			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
-		}
-		d.openStack = d.openStack[:len(d.openStack)-1]
-
-	case ArrayClose:
-		if len(d.openStack) == 0 ||
-			d.lastToken.kind == comma ||
-			d.openStack[len(d.openStack)-1] != ArrayOpen {
-			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
-		}
-		d.openStack = d.openStack[:len(d.openStack)-1]
-
-	case comma:
-		if len(d.openStack) == 0 ||
-			d.lastToken.kind&(scalar|ObjectClose|ArrayClose) == 0 {
-			return Token{}, d.newSyntaxError(tok.pos, unexpectedFmt, tok.RawString())
-		}
-	}
-
-	// Update d.lastToken only after validating token to be in the right sequence.
-	d.lastToken = tok
-
-	if d.lastToken.kind == comma {
-		return d.Read()
-	}
-	return tok, nil
-}
-
-// Any sequence that looks like a non-delimiter (for error reporting).
-var errRegexp = regexp.MustCompile(`^([-+._a-zA-Z0-9]{1,32}|.)`)
-
-// parseNext parses for the next JSON token. It returns a Token object for
-// different types, except for Name. It does not handle whether the next token
-// is in a valid sequence or not.
-func (d *Decoder) parseNext() (Token, error) {
-	// Trim leading spaces.
-	d.consume(0)
-
-	in := d.in
-	if len(in) == 0 {
-		return d.consumeToken(EOF, 0), nil
-	}
-
-	switch in[0] {
-	case 'n':
-		if n := matchWithDelim("null", in); n != 0 {
-			return d.consumeToken(Null, n), nil
-		}
-
-	case 't':
-		if n := matchWithDelim("true", in); n != 0 {
-			return d.consumeBoolToken(true, n), nil
-		}
-
-	case 'f':
-		if n := matchWithDelim("false", in); n != 0 {
-			return d.consumeBoolToken(false, n), nil
-		}
-
-	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-		if n, ok := parseNumber(in); ok {
-			return d.consumeToken(Number, n), nil
-		}
-
-	case '"':
-		s, n, err := d.parseString(in)
-		if err != nil {
-			return Token{}, err
-		}
-		return d.consumeStringToken(s, n), nil
-
-	case '{':
-		return d.consumeToken(ObjectOpen, 1), nil
-
-	case '}':
-		return d.consumeToken(ObjectClose, 1), nil
-
-	case '[':
-		return d.consumeToken(ArrayOpen, 1), nil
-
-	case ']':
-		return d.consumeToken(ArrayClose, 1), nil
-
-	case ',':
-		return d.consumeToken(comma, 1), nil
-	}
-	return Token{}, d.newSyntaxError(d.currPos(), "invalid value %s", errRegexp.Find(in))
-}
-
-// newSyntaxError returns an error with line and column information useful for
-// syntax errors.
-func (d *Decoder) newSyntaxError(pos int, f string, x ...interface{}) error {
-	e := errors.New(f, x...)
-	line, column := d.Position(pos)
-	return errors.New("syntax error (line %d:%d): %v", line, column, e)
-}
-
-// Position returns line and column number of given index of the original input.
-// It will panic if index is out of range.
-func (d *Decoder) Position(idx int) (line int, column int) {
-	b := d.orig[:idx]
-	line = bytes.Count(b, []byte("\n")) + 1
-	if i := bytes.LastIndexByte(b, '\n'); i >= 0 {
-		b = b[i+1:]
-	}
-	column = utf8.RuneCount(b) + 1 // ignore multi-rune characters
-	return line, column
-}
-
-// currPos returns the current index position of d.in from d.orig.
-func (d *Decoder) currPos() int {
-	return len(d.orig) - len(d.in)
-}
-
-// matchWithDelim matches s with the input b and verifies that the match
-// terminates with a delimiter of some form (e.g., r"[^-+_.a-zA-Z0-9]").
-// As a special case, EOF is considered a delimiter. It returns the length of s
-// if there is a match, else 0.
-func matchWithDelim(s string, b []byte) int {
-	if !bytes.HasPrefix(b, []byte(s)) {
-		return 0
-	}
-
-	n := len(s)
-	if n < len(b) && isNotDelim(b[n]) {
-		return 0
-	}
-	return n
-}
-
-// isNotDelim returns true if given byte is a not delimiter character.
-func isNotDelim(c byte) bool {
-	return (c == '-' || c == '+' || c == '.' || c == '_' ||
-		('a' <= c && c <= 'z') ||
-		('A' <= c && c <= 'Z') ||
-		('0' <= c && c <= '9'))
-}
-
-// consume consumes n bytes of input and any subsequent whitespace.
-func (d *Decoder) consume(n int) {
-	d.in = d.in[n:]
-	for len(d.in) > 0 {
-		switch d.in[0] {
-		case ' ', '\n', '\r', '\t':
-			d.in = d.in[1:]
-		default:
-			return
-		}
-	}
-}
-
-// isValueNext returns true if next type should be a JSON value: Null,
-// Number, String or Bool.
-func (d *Decoder) isValueNext() bool {
-	if len(d.openStack) == 0 {
-		return d.lastToken.kind == 0
-	}
-
-	start := d.openStack[len(d.openStack)-1]
-	switch start {
-	case ObjectOpen:
-		return d.lastToken.kind&Name != 0
-	case ArrayOpen:
-		return d.lastToken.kind&(ArrayOpen|comma) != 0
-	}
-	panic(fmt.Sprintf(
-		"unreachable logic in Decoder.isValueNext, lastToken.kind: %v, openStack: %v",
-		d.lastToken.kind, start))
-}
-
-// consumeToken constructs a Token for given Kind with raw value derived from
-// current d.in and given size, and consumes the given size-lenght of it.
-func (d *Decoder) consumeToken(kind Kind, size int) Token {
-	tok := Token{
-		kind: kind,
-		raw:  d.in[:size],
-		pos:  len(d.orig) - len(d.in),
-	}
-	d.consume(size)
-	return tok
-}
-
-// consumeBoolToken constructs a Token for a Bool kind with raw value derived from
-// current d.in and given size.
-func (d *Decoder) consumeBoolToken(b bool, size int) Token {
-	tok := Token{
-		kind: Bool,
-		raw:  d.in[:size],
-		pos:  len(d.orig) - len(d.in),
-		boo:  b,
-	}
-	d.consume(size)
-	return tok
-}
-
-// consumeStringToken constructs a Token for a String kind with raw value derived
-// from current d.in and given size.
-func (d *Decoder) consumeStringToken(s string, size int) Token {
-	tok := Token{
-		kind: String,
-		raw:  d.in[:size],
-		pos:  len(d.orig) - len(d.in),
-		str:  s,
-	}
-	d.consume(size)
-	return tok
-}
-
-// Clone returns a copy of the Decoder for use in reading ahead the next JSON
-// object, array or other values without affecting current Decoder.
-func (d *Decoder) Clone() *Decoder {
-	ret := *d
-	ret.openStack = append([]Kind(nil), ret.openStack...)
-	return &ret
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_number.go b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_number.go
deleted file mode 100644
index 2999d71..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_number.go
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json
-
-import (
-	"bytes"
-	"strconv"
-)
-
-// parseNumber reads the given []byte for a valid JSON number. If it is valid,
-// it returns the number of bytes.  Parsing logic follows the definition in
-// https://tools.ietf.org/html/rfc7159#section-6, and is based off
-// encoding/json.isValidNumber function.
-func parseNumber(input []byte) (int, bool) {
-	var n int
-
-	s := input
-	if len(s) == 0 {
-		return 0, false
-	}
-
-	// Optional -
-	if s[0] == '-' {
-		s = s[1:]
-		n++
-		if len(s) == 0 {
-			return 0, false
-		}
-	}
-
-	// Digits
-	switch {
-	case s[0] == '0':
-		s = s[1:]
-		n++
-
-	case '1' <= s[0] && s[0] <= '9':
-		s = s[1:]
-		n++
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-
-	default:
-		return 0, false
-	}
-
-	// . followed by 1 or more digits.
-	if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
-		s = s[2:]
-		n += 2
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-	}
-
-	// e or E followed by an optional - or + and
-	// 1 or more digits.
-	if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
-		s = s[1:]
-		n++
-		if s[0] == '+' || s[0] == '-' {
-			s = s[1:]
-			n++
-			if len(s) == 0 {
-				return 0, false
-			}
-		}
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-	}
-
-	// Check that next byte is a delimiter or it is at the end.
-	if n < len(input) && isNotDelim(input[n]) {
-		return 0, false
-	}
-
-	return n, true
-}
-
-// numberParts is the result of parsing out a valid JSON number. It contains
-// the parts of a number. The parts are used for integer conversion.
-type numberParts struct {
-	neg  bool
-	intp []byte
-	frac []byte
-	exp  []byte
-}
-
-// parseNumber constructs numberParts from given []byte. The logic here is
-// similar to consumeNumber above with the difference of having to construct
-// numberParts. The slice fields in numberParts are subslices of the input.
-func parseNumberParts(input []byte) (numberParts, bool) {
-	var neg bool
-	var intp []byte
-	var frac []byte
-	var exp []byte
-
-	s := input
-	if len(s) == 0 {
-		return numberParts{}, false
-	}
-
-	// Optional -
-	if s[0] == '-' {
-		neg = true
-		s = s[1:]
-		if len(s) == 0 {
-			return numberParts{}, false
-		}
-	}
-
-	// Digits
-	switch {
-	case s[0] == '0':
-		// Skip first 0 and no need to store.
-		s = s[1:]
-
-	case '1' <= s[0] && s[0] <= '9':
-		intp = s
-		n := 1
-		s = s[1:]
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-		intp = intp[:n]
-
-	default:
-		return numberParts{}, false
-	}
-
-	// . followed by 1 or more digits.
-	if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
-		frac = s[1:]
-		n := 1
-		s = s[2:]
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-		frac = frac[:n]
-	}
-
-	// e or E followed by an optional - or + and
-	// 1 or more digits.
-	if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
-		s = s[1:]
-		exp = s
-		n := 0
-		if s[0] == '+' || s[0] == '-' {
-			s = s[1:]
-			n++
-			if len(s) == 0 {
-				return numberParts{}, false
-			}
-		}
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-		exp = exp[:n]
-	}
-
-	return numberParts{
-		neg:  neg,
-		intp: intp,
-		frac: bytes.TrimRight(frac, "0"), // Remove unnecessary 0s to the right.
-		exp:  exp,
-	}, true
-}
-
-// normalizeToIntString returns an integer string in normal form without the
-// E-notation for given numberParts. It will return false if it is not an
-// integer or if the exponent exceeds than max/min int value.
-func normalizeToIntString(n numberParts) (string, bool) {
-	intpSize := len(n.intp)
-	fracSize := len(n.frac)
-
-	if intpSize == 0 && fracSize == 0 {
-		return "0", true
-	}
-
-	var exp int
-	if len(n.exp) > 0 {
-		i, err := strconv.ParseInt(string(n.exp), 10, 32)
-		if err != nil {
-			return "", false
-		}
-		exp = int(i)
-	}
-
-	var num []byte
-	if exp >= 0 {
-		// For positive E, shift fraction digits into integer part and also pad
-		// with zeroes as needed.
-
-		// If there are more digits in fraction than the E value, then the
-		// number is not an integer.
-		if fracSize > exp {
-			return "", false
-		}
-
-		// Make sure resulting digits are within max value limit to avoid
-		// unnecessarily constructing a large byte slice that may simply fail
-		// later on.
-		const maxDigits = 20 // Max uint64 value has 20 decimal digits.
-		if intpSize+exp > maxDigits {
-			return "", false
-		}
-
-		// Set cap to make a copy of integer part when appended.
-		num = n.intp[:len(n.intp):len(n.intp)]
-		num = append(num, n.frac...)
-		for i := 0; i < exp-fracSize; i++ {
-			num = append(num, '0')
-		}
-	} else {
-		// For negative E, shift digits in integer part out.
-
-		// If there are fractions, then the number is not an integer.
-		if fracSize > 0 {
-			return "", false
-		}
-
-		// index is where the decimal point will be after adjusting for negative
-		// exponent.
-		index := intpSize + exp
-		if index < 0 {
-			return "", false
-		}
-
-		num = n.intp
-		// If any of the digits being shifted to the right of the decimal point
-		// is non-zero, then the number is not an integer.
-		for i := index; i < intpSize; i++ {
-			if num[i] != '0' {
-				return "", false
-			}
-		}
-		num = num[:index]
-	}
-
-	if n.neg {
-		return "-" + string(num), true
-	}
-	return string(num), true
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_string.go b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_string.go
deleted file mode 100644
index f7fea7d..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_string.go
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json
-
-import (
-	"strconv"
-	"unicode"
-	"unicode/utf16"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/internal/strs"
-)
-
-func (d *Decoder) parseString(in []byte) (string, int, error) {
-	in0 := in
-	if len(in) == 0 {
-		return "", 0, ErrUnexpectedEOF
-	}
-	if in[0] != '"' {
-		return "", 0, d.newSyntaxError(d.currPos(), "invalid character %q at start of string", in[0])
-	}
-	in = in[1:]
-	i := indexNeedEscapeInBytes(in)
-	in, out := in[i:], in[:i:i] // set cap to prevent mutations
-	for len(in) > 0 {
-		switch r, n := utf8.DecodeRune(in); {
-		case r == utf8.RuneError && n == 1:
-			return "", 0, d.newSyntaxError(d.currPos(), "invalid UTF-8 in string")
-		case r < ' ':
-			return "", 0, d.newSyntaxError(d.currPos(), "invalid character %q in string", r)
-		case r == '"':
-			in = in[1:]
-			n := len(in0) - len(in)
-			return string(out), n, nil
-		case r == '\\':
-			if len(in) < 2 {
-				return "", 0, ErrUnexpectedEOF
-			}
-			switch r := in[1]; r {
-			case '"', '\\', '/':
-				in, out = in[2:], append(out, r)
-			case 'b':
-				in, out = in[2:], append(out, '\b')
-			case 'f':
-				in, out = in[2:], append(out, '\f')
-			case 'n':
-				in, out = in[2:], append(out, '\n')
-			case 'r':
-				in, out = in[2:], append(out, '\r')
-			case 't':
-				in, out = in[2:], append(out, '\t')
-			case 'u':
-				if len(in) < 6 {
-					return "", 0, ErrUnexpectedEOF
-				}
-				v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
-				if err != nil {
-					return "", 0, d.newSyntaxError(d.currPos(), "invalid escape code %q in string", in[:6])
-				}
-				in = in[6:]
-
-				r := rune(v)
-				if utf16.IsSurrogate(r) {
-					if len(in) < 6 {
-						return "", 0, ErrUnexpectedEOF
-					}
-					v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
-					r = utf16.DecodeRune(r, rune(v))
-					if in[0] != '\\' || in[1] != 'u' ||
-						r == unicode.ReplacementChar || err != nil {
-						return "", 0, d.newSyntaxError(d.currPos(), "invalid escape code %q in string", in[:6])
-					}
-					in = in[6:]
-				}
-				out = append(out, string(r)...)
-			default:
-				return "", 0, d.newSyntaxError(d.currPos(), "invalid escape code %q in string", in[:2])
-			}
-		default:
-			i := indexNeedEscapeInBytes(in[n:])
-			in, out = in[n+i:], append(out, in[:n+i]...)
-		}
-	}
-	return "", 0, ErrUnexpectedEOF
-}
-
-// indexNeedEscapeInBytes returns the index of the character that needs
-// escaping. If no characters need escaping, this returns the input length.
-func indexNeedEscapeInBytes(b []byte) int { return indexNeedEscapeInString(strs.UnsafeString(b)) }
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_token.go b/vendor/google.golang.org/protobuf/internal/encoding/json/decode_token.go
deleted file mode 100644
index 2eb7023..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/json/decode_token.go
+++ /dev/null
@@ -1,193 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json
-
-import (
-	"bytes"
-	"fmt"
-	"strconv"
-)
-
-// Kind represents a token kind expressible in the JSON format.
-type Kind uint16
-
-const (
-	Invalid Kind = (1 << iota) / 2
-	EOF
-	Null
-	Bool
-	Number
-	String
-	Name
-	ObjectOpen
-	ObjectClose
-	ArrayOpen
-	ArrayClose
-
-	// comma is only for parsing in between tokens and
-	// does not need to be exported.
-	comma
-)
-
-func (k Kind) String() string {
-	switch k {
-	case EOF:
-		return "eof"
-	case Null:
-		return "null"
-	case Bool:
-		return "bool"
-	case Number:
-		return "number"
-	case String:
-		return "string"
-	case ObjectOpen:
-		return "{"
-	case ObjectClose:
-		return "}"
-	case Name:
-		return "name"
-	case ArrayOpen:
-		return "["
-	case ArrayClose:
-		return "]"
-	case comma:
-		return ","
-	}
-	return "<invalid>"
-}
-
-// Token provides a parsed token kind and value.
-//
-// Values are provided by the difference accessor methods. The accessor methods
-// Name, Bool, and ParsedString will panic if called on the wrong kind. There
-// are different accessor methods for the Number kind for converting to the
-// appropriate Go numeric type and those methods have the ok return value.
-type Token struct {
-	// Token kind.
-	kind Kind
-	// pos provides the position of the token in the original input.
-	pos int
-	// raw bytes of the serialized token.
-	// This is a subslice into the original input.
-	raw []byte
-	// boo is parsed boolean value.
-	boo bool
-	// str is parsed string value.
-	str string
-}
-
-// Kind returns the token kind.
-func (t Token) Kind() Kind {
-	return t.kind
-}
-
-// RawString returns the read value in string.
-func (t Token) RawString() string {
-	return string(t.raw)
-}
-
-// Pos returns the token position from the input.
-func (t Token) Pos() int {
-	return t.pos
-}
-
-// Name returns the object name if token is Name, else it will return an error.
-func (t Token) Name() string {
-	if t.kind == Name {
-		return t.str
-	}
-	panic(fmt.Sprintf("Token is not a Name: %v", t.RawString()))
-}
-
-// Bool returns the bool value if token kind is Bool, else it panics.
-func (t Token) Bool() bool {
-	if t.kind == Bool {
-		return t.boo
-	}
-	panic(fmt.Sprintf("Token is not a Bool: %v", t.RawString()))
-}
-
-// ParsedString returns the string value for a JSON string token or the read
-// value in string if token is not a string.
-func (t Token) ParsedString() string {
-	if t.kind == String {
-		return t.str
-	}
-	panic(fmt.Sprintf("Token is not a String: %v", t.RawString()))
-}
-
-// Float returns the floating-point number if token kind is Number.
-//
-// The floating-point precision is specified by the bitSize parameter: 32 for
-// float32 or 64 for float64. If bitSize=32, the result still has type float64,
-// but it will be convertible to float32 without changing its value. It will
-// return false if the number exceeds the floating point limits for given
-// bitSize.
-func (t Token) Float(bitSize int) (float64, bool) {
-	if t.kind != Number {
-		return 0, false
-	}
-	f, err := strconv.ParseFloat(t.RawString(), bitSize)
-	if err != nil {
-		return 0, false
-	}
-	return f, true
-}
-
-// Int returns the signed integer number if token is Number.
-//
-// The given bitSize specifies the integer type that the result must fit into.
-// It returns false if the number is not an integer value or if the result
-// exceeds the limits for given bitSize.
-func (t Token) Int(bitSize int) (int64, bool) {
-	s, ok := t.getIntStr()
-	if !ok {
-		return 0, false
-	}
-	n, err := strconv.ParseInt(s, 10, bitSize)
-	if err != nil {
-		return 0, false
-	}
-	return n, true
-}
-
-// Uint returns the signed integer number if token is Number, else it will
-// return an error.
-//
-// The given bitSize specifies the unsigned integer type that the result must
-// fit into. It returns false if the number is not an unsigned integer value
-// or if the result exceeds the limits for given bitSize.
-func (t Token) Uint(bitSize int) (uint64, bool) {
-	s, ok := t.getIntStr()
-	if !ok {
-		return 0, false
-	}
-	n, err := strconv.ParseUint(s, 10, bitSize)
-	if err != nil {
-		return 0, false
-	}
-	return n, true
-}
-
-func (t Token) getIntStr() (string, bool) {
-	if t.kind != Number {
-		return "", false
-	}
-	parts, ok := parseNumberParts(t.raw)
-	if !ok {
-		return "", false
-	}
-	return normalizeToIntString(parts)
-}
-
-// TokenEquals returns true if given Tokens are equal, else false.
-func TokenEquals(x, y Token) bool {
-	return x.kind == y.kind &&
-		x.pos == y.pos &&
-		bytes.Equal(x.raw, y.raw) &&
-		x.boo == y.boo &&
-		x.str == y.str
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/json/encode.go b/vendor/google.golang.org/protobuf/internal/encoding/json/encode.go
deleted file mode 100644
index fbdf348..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/json/encode.go
+++ /dev/null
@@ -1,276 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json
-
-import (
-	"math"
-	"math/bits"
-	"strconv"
-	"strings"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/internal/detrand"
-	"google.golang.org/protobuf/internal/errors"
-)
-
-// kind represents an encoding type.
-type kind uint8
-
-const (
-	_ kind = (1 << iota) / 2
-	name
-	scalar
-	objectOpen
-	objectClose
-	arrayOpen
-	arrayClose
-)
-
-// Encoder provides methods to write out JSON constructs and values. The user is
-// responsible for producing valid sequences of JSON constructs and values.
-type Encoder struct {
-	indent   string
-	lastKind kind
-	indents  []byte
-	out      []byte
-}
-
-// NewEncoder returns an Encoder.
-//
-// If indent is a non-empty string, it causes every entry for an Array or Object
-// to be preceded by the indent and trailed by a newline.
-func NewEncoder(indent string) (*Encoder, error) {
-	e := &Encoder{}
-	if len(indent) > 0 {
-		if strings.Trim(indent, " \t") != "" {
-			return nil, errors.New("indent may only be composed of space or tab characters")
-		}
-		e.indent = indent
-	}
-	return e, nil
-}
-
-// Bytes returns the content of the written bytes.
-func (e *Encoder) Bytes() []byte {
-	return e.out
-}
-
-// WriteNull writes out the null value.
-func (e *Encoder) WriteNull() {
-	e.prepareNext(scalar)
-	e.out = append(e.out, "null"...)
-}
-
-// WriteBool writes out the given boolean value.
-func (e *Encoder) WriteBool(b bool) {
-	e.prepareNext(scalar)
-	if b {
-		e.out = append(e.out, "true"...)
-	} else {
-		e.out = append(e.out, "false"...)
-	}
-}
-
-// WriteString writes out the given string in JSON string value. Returns error
-// if input string contains invalid UTF-8.
-func (e *Encoder) WriteString(s string) error {
-	e.prepareNext(scalar)
-	var err error
-	if e.out, err = appendString(e.out, s); err != nil {
-		return err
-	}
-	return nil
-}
-
-// Sentinel error used for indicating invalid UTF-8.
-var errInvalidUTF8 = errors.New("invalid UTF-8")
-
-func appendString(out []byte, in string) ([]byte, error) {
-	out = append(out, '"')
-	i := indexNeedEscapeInString(in)
-	in, out = in[i:], append(out, in[:i]...)
-	for len(in) > 0 {
-		switch r, n := utf8.DecodeRuneInString(in); {
-		case r == utf8.RuneError && n == 1:
-			return out, errInvalidUTF8
-		case r < ' ' || r == '"' || r == '\\':
-			out = append(out, '\\')
-			switch r {
-			case '"', '\\':
-				out = append(out, byte(r))
-			case '\b':
-				out = append(out, 'b')
-			case '\f':
-				out = append(out, 'f')
-			case '\n':
-				out = append(out, 'n')
-			case '\r':
-				out = append(out, 'r')
-			case '\t':
-				out = append(out, 't')
-			default:
-				out = append(out, 'u')
-				out = append(out, "0000"[1+(bits.Len32(uint32(r))-1)/4:]...)
-				out = strconv.AppendUint(out, uint64(r), 16)
-			}
-			in = in[n:]
-		default:
-			i := indexNeedEscapeInString(in[n:])
-			in, out = in[n+i:], append(out, in[:n+i]...)
-		}
-	}
-	out = append(out, '"')
-	return out, nil
-}
-
-// indexNeedEscapeInString returns the index of the character that needs
-// escaping. If no characters need escaping, this returns the input length.
-func indexNeedEscapeInString(s string) int {
-	for i, r := range s {
-		if r < ' ' || r == '\\' || r == '"' || r == utf8.RuneError {
-			return i
-		}
-	}
-	return len(s)
-}
-
-// WriteFloat writes out the given float and bitSize in JSON number value.
-func (e *Encoder) WriteFloat(n float64, bitSize int) {
-	e.prepareNext(scalar)
-	e.out = appendFloat(e.out, n, bitSize)
-}
-
-// appendFloat formats given float in bitSize, and appends to the given []byte.
-func appendFloat(out []byte, n float64, bitSize int) []byte {
-	switch {
-	case math.IsNaN(n):
-		return append(out, `"NaN"`...)
-	case math.IsInf(n, +1):
-		return append(out, `"Infinity"`...)
-	case math.IsInf(n, -1):
-		return append(out, `"-Infinity"`...)
-	}
-
-	// JSON number formatting logic based on encoding/json.
-	// See floatEncoder.encode for reference.
-	fmt := byte('f')
-	if abs := math.Abs(n); abs != 0 {
-		if bitSize == 64 && (abs < 1e-6 || abs >= 1e21) ||
-			bitSize == 32 && (float32(abs) < 1e-6 || float32(abs) >= 1e21) {
-			fmt = 'e'
-		}
-	}
-	out = strconv.AppendFloat(out, n, fmt, -1, bitSize)
-	if fmt == 'e' {
-		n := len(out)
-		if n >= 4 && out[n-4] == 'e' && out[n-3] == '-' && out[n-2] == '0' {
-			out[n-2] = out[n-1]
-			out = out[:n-1]
-		}
-	}
-	return out
-}
-
-// WriteInt writes out the given signed integer in JSON number value.
-func (e *Encoder) WriteInt(n int64) {
-	e.prepareNext(scalar)
-	e.out = append(e.out, strconv.FormatInt(n, 10)...)
-}
-
-// WriteUint writes out the given unsigned integer in JSON number value.
-func (e *Encoder) WriteUint(n uint64) {
-	e.prepareNext(scalar)
-	e.out = append(e.out, strconv.FormatUint(n, 10)...)
-}
-
-// StartObject writes out the '{' symbol.
-func (e *Encoder) StartObject() {
-	e.prepareNext(objectOpen)
-	e.out = append(e.out, '{')
-}
-
-// EndObject writes out the '}' symbol.
-func (e *Encoder) EndObject() {
-	e.prepareNext(objectClose)
-	e.out = append(e.out, '}')
-}
-
-// WriteName writes out the given string in JSON string value and the name
-// separator ':'. Returns error if input string contains invalid UTF-8, which
-// should not be likely as protobuf field names should be valid.
-func (e *Encoder) WriteName(s string) error {
-	e.prepareNext(name)
-	var err error
-	// Append to output regardless of error.
-	e.out, err = appendString(e.out, s)
-	e.out = append(e.out, ':')
-	return err
-}
-
-// StartArray writes out the '[' symbol.
-func (e *Encoder) StartArray() {
-	e.prepareNext(arrayOpen)
-	e.out = append(e.out, '[')
-}
-
-// EndArray writes out the ']' symbol.
-func (e *Encoder) EndArray() {
-	e.prepareNext(arrayClose)
-	e.out = append(e.out, ']')
-}
-
-// prepareNext adds possible comma and indentation for the next value based
-// on last type and indent option. It also updates lastKind to next.
-func (e *Encoder) prepareNext(next kind) {
-	defer func() {
-		// Set lastKind to next.
-		e.lastKind = next
-	}()
-
-	if len(e.indent) == 0 {
-		// Need to add comma on the following condition.
-		if e.lastKind&(scalar|objectClose|arrayClose) != 0 &&
-			next&(name|scalar|objectOpen|arrayOpen) != 0 {
-			e.out = append(e.out, ',')
-			// For single-line output, add a random extra space after each
-			// comma to make output unstable.
-			if detrand.Bool() {
-				e.out = append(e.out, ' ')
-			}
-		}
-		return
-	}
-
-	switch {
-	case e.lastKind&(objectOpen|arrayOpen) != 0:
-		// If next type is NOT closing, add indent and newline.
-		if next&(objectClose|arrayClose) == 0 {
-			e.indents = append(e.indents, e.indent...)
-			e.out = append(e.out, '\n')
-			e.out = append(e.out, e.indents...)
-		}
-
-	case e.lastKind&(scalar|objectClose|arrayClose) != 0:
-		switch {
-		// If next type is either a value or name, add comma and newline.
-		case next&(name|scalar|objectOpen|arrayOpen) != 0:
-			e.out = append(e.out, ',', '\n')
-
-		// If next type is a closing object or array, adjust indentation.
-		case next&(objectClose|arrayClose) != 0:
-			e.indents = e.indents[:len(e.indents)-len(e.indent)]
-			e.out = append(e.out, '\n')
-		}
-		e.out = append(e.out, e.indents...)
-
-	case e.lastKind&name != 0:
-		e.out = append(e.out, ' ')
-		// For multi-line output, add a random extra space after key: to make
-		// output unstable.
-		if detrand.Bool() {
-			e.out = append(e.out, ' ')
-		}
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/messageset/messageset.go b/vendor/google.golang.org/protobuf/internal/encoding/messageset/messageset.go
deleted file mode 100644
index b1eeea5..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/messageset/messageset.go
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package messageset encodes and decodes the obsolete MessageSet wire format.
-package messageset
-
-import (
-	"math"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/errors"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// The MessageSet wire format is equivalent to a message defiend as follows,
-// where each Item defines an extension field with a field number of 'type_id'
-// and content of 'message'. MessageSet extensions must be non-repeated message
-// fields.
-//
-//	message MessageSet {
-//		repeated group Item = 1 {
-//			required int32 type_id = 2;
-//			required string message = 3;
-//		}
-//	}
-const (
-	FieldItem    = protowire.Number(1)
-	FieldTypeID  = protowire.Number(2)
-	FieldMessage = protowire.Number(3)
-)
-
-// ExtensionName is the field name for extensions of MessageSet.
-//
-// A valid MessageSet extension must be of the form:
-//	message MyMessage {
-//		extend proto2.bridge.MessageSet {
-//			optional MyMessage message_set_extension = 1234;
-//		}
-//		...
-//	}
-const ExtensionName = "message_set_extension"
-
-// IsMessageSet returns whether the message uses the MessageSet wire format.
-func IsMessageSet(md pref.MessageDescriptor) bool {
-	xmd, ok := md.(interface{ IsMessageSet() bool })
-	return ok && xmd.IsMessageSet()
-}
-
-// IsMessageSetExtension reports this field extends a MessageSet.
-func IsMessageSetExtension(fd pref.FieldDescriptor) bool {
-	if fd.Name() != ExtensionName {
-		return false
-	}
-	if fd.FullName().Parent() != fd.Message().FullName() {
-		return false
-	}
-	return IsMessageSet(fd.ContainingMessage())
-}
-
-// FindMessageSetExtension locates a MessageSet extension field by name.
-// In text and JSON formats, the extension name used is the message itself.
-// The extension field name is derived by appending ExtensionName.
-func FindMessageSetExtension(r preg.ExtensionTypeResolver, s pref.FullName) (pref.ExtensionType, error) {
-	name := s.Append(ExtensionName)
-	xt, err := r.FindExtensionByName(name)
-	if err != nil {
-		if err == preg.NotFound {
-			return nil, err
-		}
-		return nil, errors.Wrap(err, "%q", name)
-	}
-	if !IsMessageSetExtension(xt.TypeDescriptor()) {
-		return nil, preg.NotFound
-	}
-	return xt, nil
-}
-
-// SizeField returns the size of a MessageSet item field containing an extension
-// with the given field number, not counting the contents of the message subfield.
-func SizeField(num protowire.Number) int {
-	return 2*protowire.SizeTag(FieldItem) + protowire.SizeTag(FieldTypeID) + protowire.SizeVarint(uint64(num))
-}
-
-// Unmarshal parses a MessageSet.
-//
-// It calls fn with the type ID and value of each item in the MessageSet.
-// Unknown fields are discarded.
-//
-// If wantLen is true, the item values include the varint length prefix.
-// This is ugly, but simplifies the fast-path decoder in internal/impl.
-func Unmarshal(b []byte, wantLen bool, fn func(typeID protowire.Number, value []byte) error) error {
-	for len(b) > 0 {
-		num, wtyp, n := protowire.ConsumeTag(b)
-		if n < 0 {
-			return protowire.ParseError(n)
-		}
-		b = b[n:]
-		if num != FieldItem || wtyp != protowire.StartGroupType {
-			n := protowire.ConsumeFieldValue(num, wtyp, b)
-			if n < 0 {
-				return protowire.ParseError(n)
-			}
-			b = b[n:]
-			continue
-		}
-		typeID, value, n, err := ConsumeFieldValue(b, wantLen)
-		if err != nil {
-			return err
-		}
-		b = b[n:]
-		if typeID == 0 {
-			continue
-		}
-		if err := fn(typeID, value); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// ConsumeFieldValue parses b as a MessageSet item field value until and including
-// the trailing end group marker. It assumes the start group tag has already been parsed.
-// It returns the contents of the type_id and message subfields and the total
-// item length.
-//
-// If wantLen is true, the returned message value includes the length prefix.
-func ConsumeFieldValue(b []byte, wantLen bool) (typeid protowire.Number, message []byte, n int, err error) {
-	ilen := len(b)
-	for {
-		num, wtyp, n := protowire.ConsumeTag(b)
-		if n < 0 {
-			return 0, nil, 0, protowire.ParseError(n)
-		}
-		b = b[n:]
-		switch {
-		case num == FieldItem && wtyp == protowire.EndGroupType:
-			if wantLen && len(message) == 0 {
-				// The message field was missing, which should never happen.
-				// Be prepared for this case anyway.
-				message = protowire.AppendVarint(message, 0)
-			}
-			return typeid, message, ilen - len(b), nil
-		case num == FieldTypeID && wtyp == protowire.VarintType:
-			v, n := protowire.ConsumeVarint(b)
-			if n < 0 {
-				return 0, nil, 0, protowire.ParseError(n)
-			}
-			b = b[n:]
-			if v < 1 || v > math.MaxInt32 {
-				return 0, nil, 0, errors.New("invalid type_id in message set")
-			}
-			typeid = protowire.Number(v)
-		case num == FieldMessage && wtyp == protowire.BytesType:
-			m, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, nil, 0, protowire.ParseError(n)
-			}
-			if message == nil {
-				if wantLen {
-					message = b[:n:n]
-				} else {
-					message = m[:len(m):len(m)]
-				}
-			} else {
-				// This case should never happen in practice, but handle it for
-				// correctness: The MessageSet item contains multiple message
-				// fields, which need to be merged.
-				//
-				// In the case where we're returning the length, this becomes
-				// quite inefficient since we need to strip the length off
-				// the existing data and reconstruct it with the combined length.
-				if wantLen {
-					_, nn := protowire.ConsumeVarint(message)
-					m0 := message[nn:]
-					message = nil
-					message = protowire.AppendVarint(message, uint64(len(m0)+len(m)))
-					message = append(message, m0...)
-					message = append(message, m...)
-				} else {
-					message = append(message, m...)
-				}
-			}
-			b = b[n:]
-		default:
-			// We have no place to put it, so we just ignore unknown fields.
-			n := protowire.ConsumeFieldValue(num, wtyp, b)
-			if n < 0 {
-				return 0, nil, 0, protowire.ParseError(n)
-			}
-			b = b[n:]
-		}
-	}
-}
-
-// AppendFieldStart appends the start of a MessageSet item field containing
-// an extension with the given number. The caller must add the message
-// subfield (including the tag).
-func AppendFieldStart(b []byte, num protowire.Number) []byte {
-	b = protowire.AppendTag(b, FieldItem, protowire.StartGroupType)
-	b = protowire.AppendTag(b, FieldTypeID, protowire.VarintType)
-	b = protowire.AppendVarint(b, uint64(num))
-	return b
-}
-
-// AppendFieldEnd appends the trailing end group marker for a MessageSet item field.
-func AppendFieldEnd(b []byte) []byte {
-	return protowire.AppendTag(b, FieldItem, protowire.EndGroupType)
-}
-
-// SizeUnknown returns the size of an unknown fields section in MessageSet format.
-//
-// See AppendUnknown.
-func SizeUnknown(unknown []byte) (size int) {
-	for len(unknown) > 0 {
-		num, typ, n := protowire.ConsumeTag(unknown)
-		if n < 0 || typ != protowire.BytesType {
-			return 0
-		}
-		unknown = unknown[n:]
-		_, n = protowire.ConsumeBytes(unknown)
-		if n < 0 {
-			return 0
-		}
-		unknown = unknown[n:]
-		size += SizeField(num) + protowire.SizeTag(FieldMessage) + n
-	}
-	return size
-}
-
-// AppendUnknown appends unknown fields to b in MessageSet format.
-//
-// For historic reasons, unresolved items in a MessageSet are stored in a
-// message's unknown fields section in non-MessageSet format. That is, an
-// unknown item with typeID T and value V appears in the unknown fields as
-// a field with number T and value V.
-//
-// This function converts the unknown fields back into MessageSet form.
-func AppendUnknown(b, unknown []byte) ([]byte, error) {
-	for len(unknown) > 0 {
-		num, typ, n := protowire.ConsumeTag(unknown)
-		if n < 0 || typ != protowire.BytesType {
-			return nil, errors.New("invalid data in message set unknown fields")
-		}
-		unknown = unknown[n:]
-		_, n = protowire.ConsumeBytes(unknown)
-		if n < 0 {
-			return nil, errors.New("invalid data in message set unknown fields")
-		}
-		b = AppendFieldStart(b, num)
-		b = protowire.AppendTag(b, FieldMessage, protowire.BytesType)
-		b = append(b, unknown[:n]...)
-		b = AppendFieldEnd(b)
-		unknown = unknown[n:]
-	}
-	return b, nil
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go b/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go
deleted file mode 100644
index 16c02d7..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package tag marshals and unmarshals the legacy struct tags as generated
-// by historical versions of protoc-gen-go.
-package tag
-
-import (
-	"reflect"
-	"strconv"
-	"strings"
-
-	defval "google.golang.org/protobuf/internal/encoding/defval"
-	fdesc "google.golang.org/protobuf/internal/filedesc"
-	"google.golang.org/protobuf/internal/strs"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-var byteType = reflect.TypeOf(byte(0))
-
-// Unmarshal decodes the tag into a prototype.Field.
-//
-// The goType is needed to determine the original protoreflect.Kind since the
-// tag does not record sufficient information to determine that.
-// The type is the underlying field type (e.g., a repeated field may be
-// represented by []T, but the Go type passed in is just T).
-// A list of enum value descriptors must be provided for enum fields.
-// This does not populate the Enum or Message (except for weak message).
-//
-// This function is a best effort attempt; parsing errors are ignored.
-func Unmarshal(tag string, goType reflect.Type, evs pref.EnumValueDescriptors) pref.FieldDescriptor {
-	f := new(fdesc.Field)
-	f.L0.ParentFile = fdesc.SurrogateProto2
-	for len(tag) > 0 {
-		i := strings.IndexByte(tag, ',')
-		if i < 0 {
-			i = len(tag)
-		}
-		switch s := tag[:i]; {
-		case strings.HasPrefix(s, "name="):
-			f.L0.FullName = pref.FullName(s[len("name="):])
-		case strings.Trim(s, "0123456789") == "":
-			n, _ := strconv.ParseUint(s, 10, 32)
-			f.L1.Number = pref.FieldNumber(n)
-		case s == "opt":
-			f.L1.Cardinality = pref.Optional
-		case s == "req":
-			f.L1.Cardinality = pref.Required
-		case s == "rep":
-			f.L1.Cardinality = pref.Repeated
-		case s == "varint":
-			switch goType.Kind() {
-			case reflect.Bool:
-				f.L1.Kind = pref.BoolKind
-			case reflect.Int32:
-				f.L1.Kind = pref.Int32Kind
-			case reflect.Int64:
-				f.L1.Kind = pref.Int64Kind
-			case reflect.Uint32:
-				f.L1.Kind = pref.Uint32Kind
-			case reflect.Uint64:
-				f.L1.Kind = pref.Uint64Kind
-			}
-		case s == "zigzag32":
-			if goType.Kind() == reflect.Int32 {
-				f.L1.Kind = pref.Sint32Kind
-			}
-		case s == "zigzag64":
-			if goType.Kind() == reflect.Int64 {
-				f.L1.Kind = pref.Sint64Kind
-			}
-		case s == "fixed32":
-			switch goType.Kind() {
-			case reflect.Int32:
-				f.L1.Kind = pref.Sfixed32Kind
-			case reflect.Uint32:
-				f.L1.Kind = pref.Fixed32Kind
-			case reflect.Float32:
-				f.L1.Kind = pref.FloatKind
-			}
-		case s == "fixed64":
-			switch goType.Kind() {
-			case reflect.Int64:
-				f.L1.Kind = pref.Sfixed64Kind
-			case reflect.Uint64:
-				f.L1.Kind = pref.Fixed64Kind
-			case reflect.Float64:
-				f.L1.Kind = pref.DoubleKind
-			}
-		case s == "bytes":
-			switch {
-			case goType.Kind() == reflect.String:
-				f.L1.Kind = pref.StringKind
-			case goType.Kind() == reflect.Slice && goType.Elem() == byteType:
-				f.L1.Kind = pref.BytesKind
-			default:
-				f.L1.Kind = pref.MessageKind
-			}
-		case s == "group":
-			f.L1.Kind = pref.GroupKind
-		case strings.HasPrefix(s, "enum="):
-			f.L1.Kind = pref.EnumKind
-		case strings.HasPrefix(s, "json="):
-			jsonName := s[len("json="):]
-			if jsonName != strs.JSONCamelCase(string(f.L0.FullName.Name())) {
-				f.L1.JSONName.Init(jsonName)
-			}
-		case s == "packed":
-			f.L1.HasPacked = true
-			f.L1.IsPacked = true
-		case strings.HasPrefix(s, "weak="):
-			f.L1.IsWeak = true
-			f.L1.Message = fdesc.PlaceholderMessage(pref.FullName(s[len("weak="):]))
-		case strings.HasPrefix(s, "def="):
-			// The default tag is special in that everything afterwards is the
-			// default regardless of the presence of commas.
-			s, i = tag[len("def="):], len(tag)
-			v, ev, _ := defval.Unmarshal(s, f.L1.Kind, evs, defval.GoTag)
-			f.L1.Default = fdesc.DefaultValue(v, ev)
-		case s == "proto3":
-			f.L0.ParentFile = fdesc.SurrogateProto3
-		}
-		tag = strings.TrimPrefix(tag[i:], ",")
-	}
-
-	// The generator uses the group message name instead of the field name.
-	// We obtain the real field name by lowercasing the group name.
-	if f.L1.Kind == pref.GroupKind {
-		f.L0.FullName = pref.FullName(strings.ToLower(string(f.L0.FullName)))
-	}
-	return f
-}
-
-// Marshal encodes the protoreflect.FieldDescriptor as a tag.
-//
-// The enumName must be provided if the kind is an enum.
-// Historically, the formulation of the enum "name" was the proto package
-// dot-concatenated with the generated Go identifier for the enum type.
-// Depending on the context on how Marshal is called, there are different ways
-// through which that information is determined. As such it is the caller's
-// responsibility to provide a function to obtain that information.
-func Marshal(fd pref.FieldDescriptor, enumName string) string {
-	var tag []string
-	switch fd.Kind() {
-	case pref.BoolKind, pref.EnumKind, pref.Int32Kind, pref.Uint32Kind, pref.Int64Kind, pref.Uint64Kind:
-		tag = append(tag, "varint")
-	case pref.Sint32Kind:
-		tag = append(tag, "zigzag32")
-	case pref.Sint64Kind:
-		tag = append(tag, "zigzag64")
-	case pref.Sfixed32Kind, pref.Fixed32Kind, pref.FloatKind:
-		tag = append(tag, "fixed32")
-	case pref.Sfixed64Kind, pref.Fixed64Kind, pref.DoubleKind:
-		tag = append(tag, "fixed64")
-	case pref.StringKind, pref.BytesKind, pref.MessageKind:
-		tag = append(tag, "bytes")
-	case pref.GroupKind:
-		tag = append(tag, "group")
-	}
-	tag = append(tag, strconv.Itoa(int(fd.Number())))
-	switch fd.Cardinality() {
-	case pref.Optional:
-		tag = append(tag, "opt")
-	case pref.Required:
-		tag = append(tag, "req")
-	case pref.Repeated:
-		tag = append(tag, "rep")
-	}
-	if fd.IsPacked() {
-		tag = append(tag, "packed")
-	}
-	name := string(fd.Name())
-	if fd.Kind() == pref.GroupKind {
-		// The name of the FieldDescriptor for a group field is
-		// lowercased. To find the original capitalization, we
-		// look in the field's MessageType.
-		name = string(fd.Message().Name())
-	}
-	tag = append(tag, "name="+name)
-	if jsonName := fd.JSONName(); jsonName != "" && jsonName != name && !fd.IsExtension() {
-		// NOTE: The jsonName != name condition is suspect, but it preserve
-		// the exact same semantics from the previous generator.
-		tag = append(tag, "json="+jsonName)
-	}
-	if fd.IsWeak() {
-		tag = append(tag, "weak="+string(fd.Message().FullName()))
-	}
-	// The previous implementation does not tag extension fields as proto3,
-	// even when the field is defined in a proto3 file. Match that behavior
-	// for consistency.
-	if fd.Syntax() == pref.Proto3 && !fd.IsExtension() {
-		tag = append(tag, "proto3")
-	}
-	if fd.Kind() == pref.EnumKind && enumName != "" {
-		tag = append(tag, "enum="+enumName)
-	}
-	if fd.ContainingOneof() != nil {
-		tag = append(tag, "oneof")
-	}
-	// This must appear last in the tag, since commas in strings aren't escaped.
-	if fd.HasDefault() {
-		def, _ := defval.Marshal(fd.Default(), fd.DefaultEnumValue(), fd.Kind(), defval.GoTag)
-		tag = append(tag, "def="+def)
-	}
-	return strings.Join(tag, ",")
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go
deleted file mode 100644
index eb10ea1..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go
+++ /dev/null
@@ -1,665 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"regexp"
-	"strconv"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/internal/errors"
-)
-
-// Decoder is a token-based textproto decoder.
-type Decoder struct {
-	// lastCall is last method called, either readCall or peekCall.
-	// Initial value is readCall.
-	lastCall call
-
-	// lastToken contains the last read token.
-	lastToken Token
-
-	// lastErr contains the last read error.
-	lastErr error
-
-	// openStack is a stack containing the byte characters for MessageOpen and
-	// ListOpen kinds. The top of stack represents the message or the list that
-	// the current token is nested in. An empty stack means the current token is
-	// at the top level message. The characters '{' and '<' both represent the
-	// MessageOpen kind.
-	openStack []byte
-
-	// orig is used in reporting line and column.
-	orig []byte
-	// in contains the unconsumed input.
-	in []byte
-}
-
-// NewDecoder returns a Decoder to read the given []byte.
-func NewDecoder(b []byte) *Decoder {
-	return &Decoder{orig: b, in: b}
-}
-
-// ErrUnexpectedEOF means that EOF was encountered in the middle of the input.
-var ErrUnexpectedEOF = errors.New("%v", io.ErrUnexpectedEOF)
-
-// call specifies which Decoder method was invoked.
-type call uint8
-
-const (
-	readCall call = iota
-	peekCall
-)
-
-// Peek looks ahead and returns the next token and error without advancing a read.
-func (d *Decoder) Peek() (Token, error) {
-	defer func() { d.lastCall = peekCall }()
-	if d.lastCall == readCall {
-		d.lastToken, d.lastErr = d.Read()
-	}
-	return d.lastToken, d.lastErr
-}
-
-// Read returns the next token.
-// It will return an error if there is no valid token.
-func (d *Decoder) Read() (Token, error) {
-	defer func() { d.lastCall = readCall }()
-	if d.lastCall == peekCall {
-		return d.lastToken, d.lastErr
-	}
-
-	tok, err := d.parseNext(d.lastToken.kind)
-	if err != nil {
-		return Token{}, err
-	}
-
-	switch tok.kind {
-	case comma, semicolon:
-		tok, err = d.parseNext(tok.kind)
-		if err != nil {
-			return Token{}, err
-		}
-	}
-	d.lastToken = tok
-	return tok, nil
-}
-
-const (
-	mismatchedFmt = "mismatched close character %q"
-	unexpectedFmt = "unexpected character %q"
-)
-
-// parseNext parses the next Token based on given last kind.
-func (d *Decoder) parseNext(lastKind Kind) (Token, error) {
-	// Trim leading spaces.
-	d.consume(0)
-	isEOF := false
-	if len(d.in) == 0 {
-		isEOF = true
-	}
-
-	switch lastKind {
-	case EOF:
-		return d.consumeToken(EOF, 0, 0), nil
-
-	case bof:
-		// Start of top level message. Next token can be EOF or Name.
-		if isEOF {
-			return d.consumeToken(EOF, 0, 0), nil
-		}
-		return d.parseFieldName()
-
-	case Name:
-		// Next token can be MessageOpen, ListOpen or Scalar.
-		if isEOF {
-			return Token{}, ErrUnexpectedEOF
-		}
-		switch ch := d.in[0]; ch {
-		case '{', '<':
-			d.pushOpenStack(ch)
-			return d.consumeToken(MessageOpen, 1, 0), nil
-		case '[':
-			d.pushOpenStack(ch)
-			return d.consumeToken(ListOpen, 1, 0), nil
-		default:
-			return d.parseScalar()
-		}
-
-	case Scalar:
-		openKind, closeCh := d.currentOpenKind()
-		switch openKind {
-		case bof:
-			// Top level message.
-			// 	Next token can be EOF, comma, semicolon or Name.
-			if isEOF {
-				return d.consumeToken(EOF, 0, 0), nil
-			}
-			switch d.in[0] {
-			case ',':
-				return d.consumeToken(comma, 1, 0), nil
-			case ';':
-				return d.consumeToken(semicolon, 1, 0), nil
-			default:
-				return d.parseFieldName()
-			}
-
-		case MessageOpen:
-			// Next token can be MessageClose, comma, semicolon or Name.
-			if isEOF {
-				return Token{}, ErrUnexpectedEOF
-			}
-			switch ch := d.in[0]; ch {
-			case closeCh:
-				d.popOpenStack()
-				return d.consumeToken(MessageClose, 1, 0), nil
-			case otherCloseChar[closeCh]:
-				return Token{}, d.newSyntaxError(mismatchedFmt, ch)
-			case ',':
-				return d.consumeToken(comma, 1, 0), nil
-			case ';':
-				return d.consumeToken(semicolon, 1, 0), nil
-			default:
-				return d.parseFieldName()
-			}
-
-		case ListOpen:
-			// Next token can be ListClose or comma.
-			if isEOF {
-				return Token{}, ErrUnexpectedEOF
-			}
-			switch ch := d.in[0]; ch {
-			case ']':
-				d.popOpenStack()
-				return d.consumeToken(ListClose, 1, 0), nil
-			case ',':
-				return d.consumeToken(comma, 1, 0), nil
-			default:
-				return Token{}, d.newSyntaxError(unexpectedFmt, ch)
-			}
-		}
-
-	case MessageOpen:
-		// Next token can be MessageClose or Name.
-		if isEOF {
-			return Token{}, ErrUnexpectedEOF
-		}
-		_, closeCh := d.currentOpenKind()
-		switch ch := d.in[0]; ch {
-		case closeCh:
-			d.popOpenStack()
-			return d.consumeToken(MessageClose, 1, 0), nil
-		case otherCloseChar[closeCh]:
-			return Token{}, d.newSyntaxError(mismatchedFmt, ch)
-		default:
-			return d.parseFieldName()
-		}
-
-	case MessageClose:
-		openKind, closeCh := d.currentOpenKind()
-		switch openKind {
-		case bof:
-			// Top level message.
-			// Next token can be EOF, comma, semicolon or Name.
-			if isEOF {
-				return d.consumeToken(EOF, 0, 0), nil
-			}
-			switch ch := d.in[0]; ch {
-			case ',':
-				return d.consumeToken(comma, 1, 0), nil
-			case ';':
-				return d.consumeToken(semicolon, 1, 0), nil
-			default:
-				return d.parseFieldName()
-			}
-
-		case MessageOpen:
-			// Next token can be MessageClose, comma, semicolon or Name.
-			if isEOF {
-				return Token{}, ErrUnexpectedEOF
-			}
-			switch ch := d.in[0]; ch {
-			case closeCh:
-				d.popOpenStack()
-				return d.consumeToken(MessageClose, 1, 0), nil
-			case otherCloseChar[closeCh]:
-				return Token{}, d.newSyntaxError(mismatchedFmt, ch)
-			case ',':
-				return d.consumeToken(comma, 1, 0), nil
-			case ';':
-				return d.consumeToken(semicolon, 1, 0), nil
-			default:
-				return d.parseFieldName()
-			}
-
-		case ListOpen:
-			// Next token can be ListClose or comma
-			if isEOF {
-				return Token{}, ErrUnexpectedEOF
-			}
-			switch ch := d.in[0]; ch {
-			case closeCh:
-				d.popOpenStack()
-				return d.consumeToken(ListClose, 1, 0), nil
-			case ',':
-				return d.consumeToken(comma, 1, 0), nil
-			default:
-				return Token{}, d.newSyntaxError(unexpectedFmt, ch)
-			}
-		}
-
-	case ListOpen:
-		// Next token can be ListClose, MessageStart or Scalar.
-		if isEOF {
-			return Token{}, ErrUnexpectedEOF
-		}
-		switch ch := d.in[0]; ch {
-		case ']':
-			d.popOpenStack()
-			return d.consumeToken(ListClose, 1, 0), nil
-		case '{', '<':
-			d.pushOpenStack(ch)
-			return d.consumeToken(MessageOpen, 1, 0), nil
-		default:
-			return d.parseScalar()
-		}
-
-	case ListClose:
-		openKind, closeCh := d.currentOpenKind()
-		switch openKind {
-		case bof:
-			// Top level message.
-			// Next token can be EOF, comma, semicolon or Name.
-			if isEOF {
-				return d.consumeToken(EOF, 0, 0), nil
-			}
-			switch ch := d.in[0]; ch {
-			case ',':
-				return d.consumeToken(comma, 1, 0), nil
-			case ';':
-				return d.consumeToken(semicolon, 1, 0), nil
-			default:
-				return d.parseFieldName()
-			}
-
-		case MessageOpen:
-			// Next token can be MessageClose, comma, semicolon or Name.
-			if isEOF {
-				return Token{}, ErrUnexpectedEOF
-			}
-			switch ch := d.in[0]; ch {
-			case closeCh:
-				d.popOpenStack()
-				return d.consumeToken(MessageClose, 1, 0), nil
-			case otherCloseChar[closeCh]:
-				return Token{}, d.newSyntaxError(mismatchedFmt, ch)
-			case ',':
-				return d.consumeToken(comma, 1, 0), nil
-			case ';':
-				return d.consumeToken(semicolon, 1, 0), nil
-			default:
-				return d.parseFieldName()
-			}
-
-		default:
-			// It is not possible to have this case. Let it panic below.
-		}
-
-	case comma, semicolon:
-		openKind, closeCh := d.currentOpenKind()
-		switch openKind {
-		case bof:
-			// Top level message. Next token can be EOF or Name.
-			if isEOF {
-				return d.consumeToken(EOF, 0, 0), nil
-			}
-			return d.parseFieldName()
-
-		case MessageOpen:
-			// Next token can be MessageClose or Name.
-			if isEOF {
-				return Token{}, ErrUnexpectedEOF
-			}
-			switch ch := d.in[0]; ch {
-			case closeCh:
-				d.popOpenStack()
-				return d.consumeToken(MessageClose, 1, 0), nil
-			case otherCloseChar[closeCh]:
-				return Token{}, d.newSyntaxError(mismatchedFmt, ch)
-			default:
-				return d.parseFieldName()
-			}
-
-		case ListOpen:
-			if lastKind == semicolon {
-				// It is not be possible to have this case as logic here
-				// should not have produced a semicolon Token when inside a
-				// list. Let it panic below.
-				break
-			}
-			// Next token can be MessageOpen or Scalar.
-			if isEOF {
-				return Token{}, ErrUnexpectedEOF
-			}
-			switch ch := d.in[0]; ch {
-			case '{', '<':
-				d.pushOpenStack(ch)
-				return d.consumeToken(MessageOpen, 1, 0), nil
-			default:
-				return d.parseScalar()
-			}
-		}
-	}
-
-	line, column := d.Position(len(d.orig) - len(d.in))
-	panic(fmt.Sprintf("Decoder.parseNext: bug at handling line %d:%d with lastKind=%v", line, column, lastKind))
-}
-
-var otherCloseChar = map[byte]byte{
-	'}': '>',
-	'>': '}',
-}
-
-// currentOpenKind indicates whether current position is inside a message, list
-// or top-level message by returning MessageOpen, ListOpen or bof respectively.
-// If the returned kind is either a MessageOpen or ListOpen, it also returns the
-// corresponding closing character.
-func (d *Decoder) currentOpenKind() (Kind, byte) {
-	if len(d.openStack) == 0 {
-		return bof, 0
-	}
-	openCh := d.openStack[len(d.openStack)-1]
-	switch openCh {
-	case '{':
-		return MessageOpen, '}'
-	case '<':
-		return MessageOpen, '>'
-	case '[':
-		return ListOpen, ']'
-	}
-	panic(fmt.Sprintf("Decoder: openStack contains invalid byte %s", string(openCh)))
-}
-
-func (d *Decoder) pushOpenStack(ch byte) {
-	d.openStack = append(d.openStack, ch)
-}
-
-func (d *Decoder) popOpenStack() {
-	d.openStack = d.openStack[:len(d.openStack)-1]
-}
-
-// parseFieldName parses field name and separator.
-func (d *Decoder) parseFieldName() (tok Token, err error) {
-	defer func() {
-		if err == nil && d.tryConsumeChar(':') {
-			tok.attrs |= hasSeparator
-		}
-	}()
-
-	// Extension or Any type URL.
-	if d.in[0] == '[' {
-		return d.parseTypeName()
-	}
-
-	// Identifier.
-	if size := parseIdent(d.in, false); size > 0 {
-		return d.consumeToken(Name, size, uint8(IdentName)), nil
-	}
-
-	// Field number. Identify if input is a valid number that is not negative
-	// and is decimal integer within 32-bit range.
-	if num := parseNumber(d.in); num.size > 0 {
-		if !num.neg && num.kind == numDec {
-			if _, err := strconv.ParseInt(string(d.in[:num.size]), 10, 32); err == nil {
-				return d.consumeToken(Name, num.size, uint8(FieldNumber)), nil
-			}
-		}
-		return Token{}, d.newSyntaxError("invalid field number: %s", d.in[:num.size])
-	}
-
-	return Token{}, d.newSyntaxError("invalid field name: %s", errRegexp.Find(d.in))
-}
-
-// parseTypeName parses Any type URL or extension field name. The name is
-// enclosed in [ and ] characters. The C++ parser does not handle many legal URL
-// strings. This implementation is more liberal and allows for the pattern
-// ^[-_a-zA-Z0-9]+([./][-_a-zA-Z0-9]+)*`). Whitespaces and comments are allowed
-// in between [ ], '.', '/' and the sub names.
-func (d *Decoder) parseTypeName() (Token, error) {
-	startPos := len(d.orig) - len(d.in)
-	// Use alias s to advance first in order to use d.in for error handling.
-	// Caller already checks for [ as first character.
-	s := consume(d.in[1:], 0)
-	if len(s) == 0 {
-		return Token{}, ErrUnexpectedEOF
-	}
-
-	var name []byte
-	for len(s) > 0 && isTypeNameChar(s[0]) {
-		name = append(name, s[0])
-		s = s[1:]
-	}
-	s = consume(s, 0)
-
-	var closed bool
-	for len(s) > 0 && !closed {
-		switch {
-		case s[0] == ']':
-			s = s[1:]
-			closed = true
-
-		case s[0] == '/', s[0] == '.':
-			if len(name) > 0 && (name[len(name)-1] == '/' || name[len(name)-1] == '.') {
-				return Token{}, d.newSyntaxError("invalid type URL/extension field name: %s",
-					d.orig[startPos:len(d.orig)-len(s)+1])
-			}
-			name = append(name, s[0])
-			s = s[1:]
-			s = consume(s, 0)
-			for len(s) > 0 && isTypeNameChar(s[0]) {
-				name = append(name, s[0])
-				s = s[1:]
-			}
-			s = consume(s, 0)
-
-		default:
-			return Token{}, d.newSyntaxError(
-				"invalid type URL/extension field name: %s", d.orig[startPos:len(d.orig)-len(s)+1])
-		}
-	}
-
-	if !closed {
-		return Token{}, ErrUnexpectedEOF
-	}
-
-	// First character cannot be '.'. Last character cannot be '.' or '/'.
-	size := len(name)
-	if size == 0 || name[0] == '.' || name[size-1] == '.' || name[size-1] == '/' {
-		return Token{}, d.newSyntaxError("invalid type URL/extension field name: %s",
-			d.orig[startPos:len(d.orig)-len(s)])
-	}
-
-	d.in = s
-	endPos := len(d.orig) - len(d.in)
-	d.consume(0)
-
-	return Token{
-		kind:  Name,
-		attrs: uint8(TypeName),
-		pos:   startPos,
-		raw:   d.orig[startPos:endPos],
-		str:   string(name),
-	}, nil
-}
-
-func isTypeNameChar(b byte) bool {
-	return (b == '-' || b == '_' ||
-		('0' <= b && b <= '9') ||
-		('a' <= b && b <= 'z') ||
-		('A' <= b && b <= 'Z'))
-}
-
-func isWhiteSpace(b byte) bool {
-	switch b {
-	case ' ', '\n', '\r', '\t':
-		return true
-	default:
-		return false
-	}
-}
-
-// parseIdent parses an unquoted proto identifier and returns size.
-// If allowNeg is true, it allows '-' to be the first character in the
-// identifier. This is used when parsing literal values like -infinity, etc.
-// Regular expression matches an identifier: `^[_a-zA-Z][_a-zA-Z0-9]*`
-func parseIdent(input []byte, allowNeg bool) int {
-	var size int
-
-	s := input
-	if len(s) == 0 {
-		return 0
-	}
-
-	if allowNeg && s[0] == '-' {
-		s = s[1:]
-		size++
-		if len(s) == 0 {
-			return 0
-		}
-	}
-
-	switch {
-	case s[0] == '_',
-		'a' <= s[0] && s[0] <= 'z',
-		'A' <= s[0] && s[0] <= 'Z':
-		s = s[1:]
-		size++
-	default:
-		return 0
-	}
-
-	for len(s) > 0 && (s[0] == '_' ||
-		'a' <= s[0] && s[0] <= 'z' ||
-		'A' <= s[0] && s[0] <= 'Z' ||
-		'0' <= s[0] && s[0] <= '9') {
-		s = s[1:]
-		size++
-	}
-
-	if len(s) > 0 && !isDelim(s[0]) {
-		return 0
-	}
-
-	return size
-}
-
-// parseScalar parses for a string, literal or number value.
-func (d *Decoder) parseScalar() (Token, error) {
-	if d.in[0] == '"' || d.in[0] == '\'' {
-		return d.parseStringValue()
-	}
-
-	if tok, ok := d.parseLiteralValue(); ok {
-		return tok, nil
-	}
-
-	if tok, ok := d.parseNumberValue(); ok {
-		return tok, nil
-	}
-
-	return Token{}, d.newSyntaxError("invalid scalar value: %s", errRegexp.Find(d.in))
-}
-
-// parseLiteralValue parses a literal value. A literal value is used for
-// bools, special floats and enums. This function simply identifies that the
-// field value is a literal.
-func (d *Decoder) parseLiteralValue() (Token, bool) {
-	size := parseIdent(d.in, true)
-	if size == 0 {
-		return Token{}, false
-	}
-	return d.consumeToken(Scalar, size, literalValue), true
-}
-
-// consumeToken constructs a Token for given Kind from d.in and consumes given
-// size-length from it.
-func (d *Decoder) consumeToken(kind Kind, size int, attrs uint8) Token {
-	// Important to compute raw and pos before consuming.
-	tok := Token{
-		kind:  kind,
-		attrs: attrs,
-		pos:   len(d.orig) - len(d.in),
-		raw:   d.in[:size],
-	}
-	d.consume(size)
-	return tok
-}
-
-// newSyntaxError returns a syntax error with line and column information for
-// current position.
-func (d *Decoder) newSyntaxError(f string, x ...interface{}) error {
-	e := errors.New(f, x...)
-	line, column := d.Position(len(d.orig) - len(d.in))
-	return errors.New("syntax error (line %d:%d): %v", line, column, e)
-}
-
-// Position returns line and column number of given index of the original input.
-// It will panic if index is out of range.
-func (d *Decoder) Position(idx int) (line int, column int) {
-	b := d.orig[:idx]
-	line = bytes.Count(b, []byte("\n")) + 1
-	if i := bytes.LastIndexByte(b, '\n'); i >= 0 {
-		b = b[i+1:]
-	}
-	column = utf8.RuneCount(b) + 1 // ignore multi-rune characters
-	return line, column
-}
-
-func (d *Decoder) tryConsumeChar(c byte) bool {
-	if len(d.in) > 0 && d.in[0] == c {
-		d.consume(1)
-		return true
-	}
-	return false
-}
-
-// consume consumes n bytes of input and any subsequent whitespace or comments.
-func (d *Decoder) consume(n int) {
-	d.in = consume(d.in, n)
-	return
-}
-
-// consume consumes n bytes of input and any subsequent whitespace or comments.
-func consume(b []byte, n int) []byte {
-	b = b[n:]
-	for len(b) > 0 {
-		switch b[0] {
-		case ' ', '\n', '\r', '\t':
-			b = b[1:]
-		case '#':
-			if i := bytes.IndexByte(b, '\n'); i >= 0 {
-				b = b[i+len("\n"):]
-			} else {
-				b = nil
-			}
-		default:
-			return b
-		}
-	}
-	return b
-}
-
-// Any sequence that looks like a non-delimiter (for error reporting).
-var errRegexp = regexp.MustCompile(`^([-+._a-zA-Z0-9\/]+|.)`)
-
-// isDelim returns true if given byte is a delimiter character.
-func isDelim(c byte) bool {
-	return !(c == '-' || c == '+' || c == '.' || c == '_' ||
-		('a' <= c && c <= 'z') ||
-		('A' <= c && c <= 'Z') ||
-		('0' <= c && c <= '9'))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go
deleted file mode 100644
index f2d90b7..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go
+++ /dev/null
@@ -1,190 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-// parseNumberValue parses a number from the input and returns a Token object.
-func (d *Decoder) parseNumberValue() (Token, bool) {
-	in := d.in
-	num := parseNumber(in)
-	if num.size == 0 {
-		return Token{}, false
-	}
-	numAttrs := num.kind
-	if num.neg {
-		numAttrs |= isNegative
-	}
-	strSize := num.size
-	last := num.size - 1
-	if num.kind == numFloat && (d.in[last] == 'f' || d.in[last] == 'F') {
-		strSize = last
-	}
-	tok := Token{
-		kind:     Scalar,
-		attrs:    numberValue,
-		pos:      len(d.orig) - len(d.in),
-		raw:      d.in[:num.size],
-		str:      string(d.in[:strSize]),
-		numAttrs: numAttrs,
-	}
-	d.consume(num.size)
-	return tok, true
-}
-
-const (
-	numDec uint8 = (1 << iota) / 2
-	numHex
-	numOct
-	numFloat
-)
-
-// number is the result of parsing out a valid number from parseNumber. It
-// contains data for doing float or integer conversion via the strconv package
-// in conjunction with the input bytes.
-type number struct {
-	kind uint8
-	neg  bool
-	size int
-}
-
-// parseNumber constructs a number object from given input. It allows for the
-// following patterns:
-//   integer: ^-?([1-9][0-9]*|0[xX][0-9a-fA-F]+|0[0-7]*)
-//   float: ^-?((0|[1-9][0-9]*)?([.][0-9]*)?([eE][+-]?[0-9]+)?[fF]?)
-// It also returns the number of parsed bytes for the given number, 0 if it is
-// not a number.
-func parseNumber(input []byte) number {
-	kind := numDec
-	var size int
-	var neg bool
-
-	s := input
-	if len(s) == 0 {
-		return number{}
-	}
-
-	// Optional -
-	if s[0] == '-' {
-		neg = true
-		s = s[1:]
-		size++
-		if len(s) == 0 {
-			return number{}
-		}
-	}
-
-	// C++ allows for whitespace and comments in between the negative sign and
-	// the rest of the number. This logic currently does not but is consistent
-	// with v1.
-
-	switch {
-	case s[0] == '0':
-		if len(s) > 1 {
-			switch {
-			case s[1] == 'x' || s[1] == 'X':
-				// Parse as hex number.
-				kind = numHex
-				n := 2
-				s = s[2:]
-				for len(s) > 0 && (('0' <= s[0] && s[0] <= '9') ||
-					('a' <= s[0] && s[0] <= 'f') ||
-					('A' <= s[0] && s[0] <= 'F')) {
-					s = s[1:]
-					n++
-				}
-				if n == 2 {
-					return number{}
-				}
-				size += n
-
-			case '0' <= s[1] && s[1] <= '7':
-				// Parse as octal number.
-				kind = numOct
-				n := 2
-				s = s[2:]
-				for len(s) > 0 && '0' <= s[0] && s[0] <= '7' {
-					s = s[1:]
-					n++
-				}
-				size += n
-			}
-
-			if kind&(numHex|numOct) > 0 {
-				if len(s) > 0 && !isDelim(s[0]) {
-					return number{}
-				}
-				return number{kind: kind, neg: neg, size: size}
-			}
-		}
-		s = s[1:]
-		size++
-
-	case '1' <= s[0] && s[0] <= '9':
-		n := 1
-		s = s[1:]
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-		size += n
-
-	case s[0] == '.':
-		// Set kind to numFloat to signify the intent to parse as float. And
-		// that it needs to have other digits after '.'.
-		kind = numFloat
-
-	default:
-		return number{}
-	}
-
-	// . followed by 0 or more digits.
-	if len(s) > 0 && s[0] == '.' {
-		n := 1
-		s = s[1:]
-		// If decimal point was before any digits, it should be followed by
-		// other digits.
-		if len(s) == 0 && kind == numFloat {
-			return number{}
-		}
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-		size += n
-		kind = numFloat
-	}
-
-	// e or E followed by an optional - or + and 1 or more digits.
-	if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
-		kind = numFloat
-		s = s[1:]
-		n := 1
-		if s[0] == '+' || s[0] == '-' {
-			s = s[1:]
-			n++
-			if len(s) == 0 {
-				return number{}
-			}
-		}
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-		size += n
-	}
-
-	// Optional suffix f or F for floats.
-	if len(s) > 0 && (s[0] == 'f' || s[0] == 'F') {
-		kind = numFloat
-		s = s[1:]
-		size++
-	}
-
-	// Check that next byte is a delimiter or it is at the end.
-	if len(s) > 0 && !isDelim(s[0]) {
-		return number{}
-	}
-
-	return number{kind: kind, neg: neg, size: size}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go
deleted file mode 100644
index d4d3490..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-import (
-	"bytes"
-	"strconv"
-	"strings"
-	"unicode"
-	"unicode/utf16"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/internal/strs"
-)
-
-// parseStringValue parses string field token.
-// This differs from parseString since the text format allows
-// multiple back-to-back string literals where they are semantically treated
-// as a single large string with all values concatenated.
-//
-// E.g., `"foo" "bar" "baz"` => "foobarbaz"
-func (d *Decoder) parseStringValue() (Token, error) {
-	// Note that the ending quote is sufficient to unambiguously mark the end
-	// of a string. Thus, the text grammar does not require intervening
-	// whitespace or control characters in-between strings.
-	// Thus, the following is valid:
-	//	`"foo"'bar'"baz"` => "foobarbaz"
-	in0 := d.in
-	var ss []string
-	for len(d.in) > 0 && (d.in[0] == '"' || d.in[0] == '\'') {
-		s, err := d.parseString()
-		if err != nil {
-			return Token{}, err
-		}
-		ss = append(ss, s)
-	}
-	// d.in already points to the end of the value at this point.
-	return Token{
-		kind:  Scalar,
-		attrs: stringValue,
-		pos:   len(d.orig) - len(in0),
-		raw:   in0[:len(in0)-len(d.in)],
-		str:   strings.Join(ss, ""),
-	}, nil
-}
-
-// parseString parses a string value enclosed in " or '.
-func (d *Decoder) parseString() (string, error) {
-	in := d.in
-	if len(in) == 0 {
-		return "", ErrUnexpectedEOF
-	}
-	quote := in[0]
-	in = in[1:]
-	i := indexNeedEscapeInBytes(in)
-	in, out := in[i:], in[:i:i] // set cap to prevent mutations
-	for len(in) > 0 {
-		switch r, n := utf8.DecodeRune(in); {
-		case r == utf8.RuneError && n == 1:
-			return "", d.newSyntaxError("invalid UTF-8 detected")
-		case r == 0 || r == '\n':
-			return "", d.newSyntaxError("invalid character %q in string", r)
-		case r == rune(quote):
-			in = in[1:]
-			d.consume(len(d.in) - len(in))
-			return string(out), nil
-		case r == '\\':
-			if len(in) < 2 {
-				return "", ErrUnexpectedEOF
-			}
-			switch r := in[1]; r {
-			case '"', '\'', '\\', '?':
-				in, out = in[2:], append(out, r)
-			case 'a':
-				in, out = in[2:], append(out, '\a')
-			case 'b':
-				in, out = in[2:], append(out, '\b')
-			case 'n':
-				in, out = in[2:], append(out, '\n')
-			case 'r':
-				in, out = in[2:], append(out, '\r')
-			case 't':
-				in, out = in[2:], append(out, '\t')
-			case 'v':
-				in, out = in[2:], append(out, '\v')
-			case 'f':
-				in, out = in[2:], append(out, '\f')
-			case '0', '1', '2', '3', '4', '5', '6', '7':
-				// One, two, or three octal characters.
-				n := len(in[1:]) - len(bytes.TrimLeft(in[1:], "01234567"))
-				if n > 3 {
-					n = 3
-				}
-				v, err := strconv.ParseUint(string(in[1:1+n]), 8, 8)
-				if err != nil {
-					return "", d.newSyntaxError("invalid octal escape code %q in string", in[:1+n])
-				}
-				in, out = in[1+n:], append(out, byte(v))
-			case 'x':
-				// One or two hexadecimal characters.
-				n := len(in[2:]) - len(bytes.TrimLeft(in[2:], "0123456789abcdefABCDEF"))
-				if n > 2 {
-					n = 2
-				}
-				v, err := strconv.ParseUint(string(in[2:2+n]), 16, 8)
-				if err != nil {
-					return "", d.newSyntaxError("invalid hex escape code %q in string", in[:2+n])
-				}
-				in, out = in[2+n:], append(out, byte(v))
-			case 'u', 'U':
-				// Four or eight hexadecimal characters
-				n := 6
-				if r == 'U' {
-					n = 10
-				}
-				if len(in) < n {
-					return "", ErrUnexpectedEOF
-				}
-				v, err := strconv.ParseUint(string(in[2:n]), 16, 32)
-				if utf8.MaxRune < v || err != nil {
-					return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:n])
-				}
-				in = in[n:]
-
-				r := rune(v)
-				if utf16.IsSurrogate(r) {
-					if len(in) < 6 {
-						return "", ErrUnexpectedEOF
-					}
-					v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
-					r = utf16.DecodeRune(r, rune(v))
-					if in[0] != '\\' || in[1] != 'u' || r == unicode.ReplacementChar || err != nil {
-						return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:6])
-					}
-					in = in[6:]
-				}
-				out = append(out, string(r)...)
-			default:
-				return "", d.newSyntaxError("invalid escape code %q in string", in[:2])
-			}
-		default:
-			i := indexNeedEscapeInBytes(in[n:])
-			in, out = in[n+i:], append(out, in[:n+i]...)
-		}
-	}
-	return "", ErrUnexpectedEOF
-}
-
-// indexNeedEscapeInString returns the index of the character that needs
-// escaping. If no characters need escaping, this returns the input length.
-func indexNeedEscapeInBytes(b []byte) int { return indexNeedEscapeInString(strs.UnsafeString(b)) }
-
-// UnmarshalString returns an unescaped string given a textproto string value.
-// String value needs to contain single or double quotes. This is only used by
-// internal/encoding/defval package for unmarshaling bytes.
-func UnmarshalString(s string) (string, error) {
-	d := NewDecoder([]byte(s))
-	return d.parseString()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go b/vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go
deleted file mode 100644
index 83d2b0d..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go
+++ /dev/null
@@ -1,373 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-import (
-	"bytes"
-	"fmt"
-	"math"
-	"strconv"
-	"strings"
-
-	"google.golang.org/protobuf/internal/flags"
-)
-
-// Kind represents a token kind expressible in the textproto format.
-type Kind uint8
-
-// Kind values.
-const (
-	Invalid Kind = iota
-	EOF
-	Name   // Name indicates the field name.
-	Scalar // Scalar are scalar values, e.g. "string", 47, ENUM_LITERAL, true.
-	MessageOpen
-	MessageClose
-	ListOpen
-	ListClose
-
-	// comma and semi-colon are only for parsing in between values and should not be exposed.
-	comma
-	semicolon
-
-	// bof indicates beginning of file, which is the default token
-	// kind at the beginning of parsing.
-	bof = Invalid
-)
-
-func (t Kind) String() string {
-	switch t {
-	case Invalid:
-		return "<invalid>"
-	case EOF:
-		return "eof"
-	case Scalar:
-		return "scalar"
-	case Name:
-		return "name"
-	case MessageOpen:
-		return "{"
-	case MessageClose:
-		return "}"
-	case ListOpen:
-		return "["
-	case ListClose:
-		return "]"
-	case comma:
-		return ","
-	case semicolon:
-		return ";"
-	default:
-		return fmt.Sprintf("<invalid:%v>", uint8(t))
-	}
-}
-
-// NameKind represents different types of field names.
-type NameKind uint8
-
-// NameKind values.
-const (
-	IdentName NameKind = iota + 1
-	TypeName
-	FieldNumber
-)
-
-func (t NameKind) String() string {
-	switch t {
-	case IdentName:
-		return "IdentName"
-	case TypeName:
-		return "TypeName"
-	case FieldNumber:
-		return "FieldNumber"
-	default:
-		return fmt.Sprintf("<invalid:%v>", uint8(t))
-	}
-}
-
-// Bit mask in Token.attrs to indicate if a Name token is followed by the
-// separator char ':'. The field name separator char is optional for message
-// field or repeated message field, but required for all other types. Decoder
-// simply indicates whether a Name token is followed by separator or not.  It is
-// up to the prototext package to validate.
-const hasSeparator = 1 << 7
-
-// Scalar value types.
-const (
-	numberValue = iota + 1
-	stringValue
-	literalValue
-)
-
-// Bit mask in Token.numAttrs to indicate that the number is a negative.
-const isNegative = 1 << 7
-
-// Token provides a parsed token kind and value. Values are provided by the
-// different accessor methods.
-type Token struct {
-	// Kind of the Token object.
-	kind Kind
-	// attrs contains metadata for the following Kinds:
-	// Name: hasSeparator bit and one of NameKind.
-	// Scalar: one of numberValue, stringValue, literalValue.
-	attrs uint8
-	// numAttrs contains metadata for numberValue:
-	// - highest bit is whether negative or positive.
-	// - lower bits indicate one of numDec, numHex, numOct, numFloat.
-	numAttrs uint8
-	// pos provides the position of the token in the original input.
-	pos int
-	// raw bytes of the serialized token.
-	// This is a subslice into the original input.
-	raw []byte
-	// str contains parsed string for the following:
-	// - stringValue of Scalar kind
-	// - numberValue of Scalar kind
-	// - TypeName of Name kind
-	str string
-}
-
-// Kind returns the token kind.
-func (t Token) Kind() Kind {
-	return t.kind
-}
-
-// RawString returns the read value in string.
-func (t Token) RawString() string {
-	return string(t.raw)
-}
-
-// Pos returns the token position from the input.
-func (t Token) Pos() int {
-	return t.pos
-}
-
-// NameKind returns IdentName, TypeName or FieldNumber.
-// It panics if type is not Name.
-func (t Token) NameKind() NameKind {
-	if t.kind == Name {
-		return NameKind(t.attrs &^ hasSeparator)
-	}
-	panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
-}
-
-// HasSeparator returns true if the field name is followed by the separator char
-// ':', else false. It panics if type is not Name.
-func (t Token) HasSeparator() bool {
-	if t.kind == Name {
-		return t.attrs&hasSeparator != 0
-	}
-	panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
-}
-
-// IdentName returns the value for IdentName type.
-func (t Token) IdentName() string {
-	if t.kind == Name && t.attrs&uint8(IdentName) != 0 {
-		return string(t.raw)
-	}
-	panic(fmt.Sprintf("Token is not an IdentName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
-}
-
-// TypeName returns the value for TypeName type.
-func (t Token) TypeName() string {
-	if t.kind == Name && t.attrs&uint8(TypeName) != 0 {
-		return t.str
-	}
-	panic(fmt.Sprintf("Token is not a TypeName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
-}
-
-// FieldNumber returns the value for FieldNumber type. It returns a
-// non-negative int32 value. Caller will still need to validate for the correct
-// field number range.
-func (t Token) FieldNumber() int32 {
-	if t.kind != Name || t.attrs&uint8(FieldNumber) == 0 {
-		panic(fmt.Sprintf("Token is not a FieldNumber: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
-	}
-	// Following should not return an error as it had already been called right
-	// before this Token was constructed.
-	num, _ := strconv.ParseInt(string(t.raw), 10, 32)
-	return int32(num)
-}
-
-// String returns the string value for a Scalar type.
-func (t Token) String() (string, bool) {
-	if t.kind != Scalar || t.attrs != stringValue {
-		return "", false
-	}
-	return t.str, true
-}
-
-// Enum returns the literal value for a Scalar type for use as enum literals.
-func (t Token) Enum() (string, bool) {
-	if t.kind != Scalar || t.attrs != literalValue || (len(t.raw) > 0 && t.raw[0] == '-') {
-		return "", false
-	}
-	return string(t.raw), true
-}
-
-// Bool returns the bool value for a Scalar type.
-func (t Token) Bool() (bool, bool) {
-	if t.kind != Scalar {
-		return false, false
-	}
-	switch t.attrs {
-	case literalValue:
-		if b, ok := boolLits[string(t.raw)]; ok {
-			return b, true
-		}
-	case numberValue:
-		// Unsigned integer representation of 0 or 1 is permitted: 00, 0x0, 01,
-		// 0x1, etc.
-		n, err := strconv.ParseUint(t.str, 0, 64)
-		if err == nil {
-			switch n {
-			case 0:
-				return false, true
-			case 1:
-				return true, true
-			}
-		}
-	}
-	return false, false
-}
-
-// These exact boolean literals are the ones supported in C++.
-var boolLits = map[string]bool{
-	"t":     true,
-	"true":  true,
-	"True":  true,
-	"f":     false,
-	"false": false,
-	"False": false,
-}
-
-// Uint64 returns the uint64 value for a Scalar type.
-func (t Token) Uint64() (uint64, bool) {
-	if t.kind != Scalar || t.attrs != numberValue ||
-		t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {
-		return 0, false
-	}
-	n, err := strconv.ParseUint(t.str, 0, 64)
-	if err != nil {
-		return 0, false
-	}
-	return n, true
-}
-
-// Uint32 returns the uint32 value for a Scalar type.
-func (t Token) Uint32() (uint32, bool) {
-	if t.kind != Scalar || t.attrs != numberValue ||
-		t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {
-		return 0, false
-	}
-	n, err := strconv.ParseUint(t.str, 0, 32)
-	if err != nil {
-		return 0, false
-	}
-	return uint32(n), true
-}
-
-// Int64 returns the int64 value for a Scalar type.
-func (t Token) Int64() (int64, bool) {
-	if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {
-		return 0, false
-	}
-	if n, err := strconv.ParseInt(t.str, 0, 64); err == nil {
-		return n, true
-	}
-	// C++ accepts large positive hex numbers as negative values.
-	// This feature is here for proto1 backwards compatibility purposes.
-	if flags.ProtoLegacy && (t.numAttrs == numHex) {
-		if n, err := strconv.ParseUint(t.str, 0, 64); err == nil {
-			return int64(n), true
-		}
-	}
-	return 0, false
-}
-
-// Int32 returns the int32 value for a Scalar type.
-func (t Token) Int32() (int32, bool) {
-	if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {
-		return 0, false
-	}
-	if n, err := strconv.ParseInt(t.str, 0, 32); err == nil {
-		return int32(n), true
-	}
-	// C++ accepts large positive hex numbers as negative values.
-	// This feature is here for proto1 backwards compatibility purposes.
-	if flags.ProtoLegacy && (t.numAttrs == numHex) {
-		if n, err := strconv.ParseUint(t.str, 0, 32); err == nil {
-			return int32(n), true
-		}
-	}
-	return 0, false
-}
-
-// Float64 returns the float64 value for a Scalar type.
-func (t Token) Float64() (float64, bool) {
-	if t.kind != Scalar {
-		return 0, false
-	}
-	switch t.attrs {
-	case literalValue:
-		if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {
-			return f, true
-		}
-	case numberValue:
-		n, err := strconv.ParseFloat(t.str, 64)
-		if err == nil {
-			return n, true
-		}
-		nerr := err.(*strconv.NumError)
-		if nerr.Err == strconv.ErrRange {
-			return n, true
-		}
-	}
-	return 0, false
-}
-
-// Float32 returns the float32 value for a Scalar type.
-func (t Token) Float32() (float32, bool) {
-	if t.kind != Scalar {
-		return 0, false
-	}
-	switch t.attrs {
-	case literalValue:
-		if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {
-			return float32(f), true
-		}
-	case numberValue:
-		n, err := strconv.ParseFloat(t.str, 64)
-		if err == nil {
-			// Overflows are treated as (-)infinity.
-			return float32(n), true
-		}
-		nerr := err.(*strconv.NumError)
-		if nerr.Err == strconv.ErrRange {
-			return float32(n), true
-		}
-	}
-	return 0, false
-}
-
-// These are the supported float literals which C++ permits case-insensitive
-// variants of these.
-var floatLits = map[string]float64{
-	"nan":       math.NaN(),
-	"inf":       math.Inf(1),
-	"infinity":  math.Inf(1),
-	"-inf":      math.Inf(-1),
-	"-infinity": math.Inf(-1),
-}
-
-// TokenEquals returns true if given Tokens are equal, else false.
-func TokenEquals(x, y Token) bool {
-	return x.kind == y.kind &&
-		x.attrs == y.attrs &&
-		x.numAttrs == y.numAttrs &&
-		x.pos == y.pos &&
-		bytes.Equal(x.raw, y.raw) &&
-		x.str == y.str
-}
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/doc.go b/vendor/google.golang.org/protobuf/internal/encoding/text/doc.go
deleted file mode 100644
index 0ce8d6f..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/doc.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package text implements the text format for protocol buffers.
-// This package has no semantic understanding for protocol buffers and is only
-// a parser and composer for the format.
-//
-// There is no formal specification for the protobuf text format, as such the
-// C++ implementation (see google::protobuf::TextFormat) is the reference
-// implementation of the text format.
-//
-// This package is neither a superset nor a subset of the C++ implementation.
-// This implementation permits a more liberal grammar in some cases to be
-// backwards compatible with the historical Go implementation.
-// Future parsings unique to Go should not be added.
-// Some grammars allowed by the C++ implementation are deliberately
-// not implemented here because they are considered a bug by the protobuf team
-// and should not be replicated.
-//
-// The Go implementation should implement a sufficient amount of the C++
-// grammar such that the default text serialization by C++ can be parsed by Go.
-// However, just because the C++ parser accepts some input does not mean that
-// the Go implementation should as well.
-//
-// The text format is almost a superset of JSON except:
-//	* message keys are not quoted strings, but identifiers
-//	* the top-level value must be a message without the delimiters
-package text
diff --git a/vendor/google.golang.org/protobuf/internal/encoding/text/encode.go b/vendor/google.golang.org/protobuf/internal/encoding/text/encode.go
deleted file mode 100644
index c4ba1c5..0000000
--- a/vendor/google.golang.org/protobuf/internal/encoding/text/encode.go
+++ /dev/null
@@ -1,267 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package text
-
-import (
-	"math"
-	"math/bits"
-	"strconv"
-	"strings"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/internal/detrand"
-	"google.golang.org/protobuf/internal/errors"
-)
-
-// encType represents an encoding type.
-type encType uint8
-
-const (
-	_ encType = (1 << iota) / 2
-	name
-	scalar
-	messageOpen
-	messageClose
-)
-
-// Encoder provides methods to write out textproto constructs and values. The user is
-// responsible for producing valid sequences of constructs and values.
-type Encoder struct {
-	encoderState
-
-	indent      string
-	newline     string // set to "\n" if len(indent) > 0
-	delims      [2]byte
-	outputASCII bool
-}
-
-type encoderState struct {
-	lastType encType
-	indents  []byte
-	out      []byte
-}
-
-// NewEncoder returns an Encoder.
-//
-// If indent is a non-empty string, it causes every entry in a List or Message
-// to be preceded by the indent and trailed by a newline.
-//
-// If delims is not the zero value, it controls the delimiter characters used
-// for messages (e.g., "{}" vs "<>").
-//
-// If outputASCII is true, strings will be serialized in such a way that
-// multi-byte UTF-8 sequences are escaped. This property ensures that the
-// overall output is ASCII (as opposed to UTF-8).
-func NewEncoder(indent string, delims [2]byte, outputASCII bool) (*Encoder, error) {
-	e := &Encoder{}
-	if len(indent) > 0 {
-		if strings.Trim(indent, " \t") != "" {
-			return nil, errors.New("indent may only be composed of space and tab characters")
-		}
-		e.indent = indent
-		e.newline = "\n"
-	}
-	switch delims {
-	case [2]byte{0, 0}:
-		e.delims = [2]byte{'{', '}'}
-	case [2]byte{'{', '}'}, [2]byte{'<', '>'}:
-		e.delims = delims
-	default:
-		return nil, errors.New("delimiters may only be \"{}\" or \"<>\"")
-	}
-	e.outputASCII = outputASCII
-
-	return e, nil
-}
-
-// Bytes returns the content of the written bytes.
-func (e *Encoder) Bytes() []byte {
-	return e.out
-}
-
-// StartMessage writes out the '{' or '<' symbol.
-func (e *Encoder) StartMessage() {
-	e.prepareNext(messageOpen)
-	e.out = append(e.out, e.delims[0])
-}
-
-// EndMessage writes out the '}' or '>' symbol.
-func (e *Encoder) EndMessage() {
-	e.prepareNext(messageClose)
-	e.out = append(e.out, e.delims[1])
-}
-
-// WriteName writes out the field name and the separator ':'.
-func (e *Encoder) WriteName(s string) {
-	e.prepareNext(name)
-	e.out = append(e.out, s...)
-	e.out = append(e.out, ':')
-}
-
-// WriteBool writes out the given boolean value.
-func (e *Encoder) WriteBool(b bool) {
-	if b {
-		e.WriteLiteral("true")
-	} else {
-		e.WriteLiteral("false")
-	}
-}
-
-// WriteString writes out the given string value.
-func (e *Encoder) WriteString(s string) {
-	e.prepareNext(scalar)
-	e.out = appendString(e.out, s, e.outputASCII)
-}
-
-func appendString(out []byte, in string, outputASCII bool) []byte {
-	out = append(out, '"')
-	i := indexNeedEscapeInString(in)
-	in, out = in[i:], append(out, in[:i]...)
-	for len(in) > 0 {
-		switch r, n := utf8.DecodeRuneInString(in); {
-		case r == utf8.RuneError && n == 1:
-			// We do not report invalid UTF-8 because strings in the text format
-			// are used to represent both the proto string and bytes type.
-			r = rune(in[0])
-			fallthrough
-		case r < ' ' || r == '"' || r == '\\':
-			out = append(out, '\\')
-			switch r {
-			case '"', '\\':
-				out = append(out, byte(r))
-			case '\n':
-				out = append(out, 'n')
-			case '\r':
-				out = append(out, 'r')
-			case '\t':
-				out = append(out, 't')
-			default:
-				out = append(out, 'x')
-				out = append(out, "00"[1+(bits.Len32(uint32(r))-1)/4:]...)
-				out = strconv.AppendUint(out, uint64(r), 16)
-			}
-			in = in[n:]
-		case outputASCII && r >= utf8.RuneSelf:
-			out = append(out, '\\')
-			if r <= math.MaxUint16 {
-				out = append(out, 'u')
-				out = append(out, "0000"[1+(bits.Len32(uint32(r))-1)/4:]...)
-				out = strconv.AppendUint(out, uint64(r), 16)
-			} else {
-				out = append(out, 'U')
-				out = append(out, "00000000"[1+(bits.Len32(uint32(r))-1)/4:]...)
-				out = strconv.AppendUint(out, uint64(r), 16)
-			}
-			in = in[n:]
-		default:
-			i := indexNeedEscapeInString(in[n:])
-			in, out = in[n+i:], append(out, in[:n+i]...)
-		}
-	}
-	out = append(out, '"')
-	return out
-}
-
-// indexNeedEscapeInString returns the index of the character that needs
-// escaping. If no characters need escaping, this returns the input length.
-func indexNeedEscapeInString(s string) int {
-	for i := 0; i < len(s); i++ {
-		if c := s[i]; c < ' ' || c == '"' || c == '\'' || c == '\\' || c >= utf8.RuneSelf {
-			return i
-		}
-	}
-	return len(s)
-}
-
-// WriteFloat writes out the given float value for given bitSize.
-func (e *Encoder) WriteFloat(n float64, bitSize int) {
-	e.prepareNext(scalar)
-	e.out = appendFloat(e.out, n, bitSize)
-}
-
-func appendFloat(out []byte, n float64, bitSize int) []byte {
-	switch {
-	case math.IsNaN(n):
-		return append(out, "nan"...)
-	case math.IsInf(n, +1):
-		return append(out, "inf"...)
-	case math.IsInf(n, -1):
-		return append(out, "-inf"...)
-	default:
-		return strconv.AppendFloat(out, n, 'g', -1, bitSize)
-	}
-}
-
-// WriteInt writes out the given signed integer value.
-func (e *Encoder) WriteInt(n int64) {
-	e.prepareNext(scalar)
-	e.out = append(e.out, strconv.FormatInt(n, 10)...)
-}
-
-// WriteUint writes out the given unsigned integer value.
-func (e *Encoder) WriteUint(n uint64) {
-	e.prepareNext(scalar)
-	e.out = append(e.out, strconv.FormatUint(n, 10)...)
-}
-
-// WriteLiteral writes out the given string as a literal value without quotes.
-// This is used for writing enum literal strings.
-func (e *Encoder) WriteLiteral(s string) {
-	e.prepareNext(scalar)
-	e.out = append(e.out, s...)
-}
-
-// prepareNext adds possible space and indentation for the next value based
-// on last encType and indent option. It also updates e.lastType to next.
-func (e *Encoder) prepareNext(next encType) {
-	defer func() {
-		e.lastType = next
-	}()
-
-	// Single line.
-	if len(e.indent) == 0 {
-		// Add space after each field before the next one.
-		if e.lastType&(scalar|messageClose) != 0 && next == name {
-			e.out = append(e.out, ' ')
-			// Add a random extra space to make output unstable.
-			if detrand.Bool() {
-				e.out = append(e.out, ' ')
-			}
-		}
-		return
-	}
-
-	// Multi-line.
-	switch {
-	case e.lastType == name:
-		e.out = append(e.out, ' ')
-		// Add a random extra space after name: to make output unstable.
-		if detrand.Bool() {
-			e.out = append(e.out, ' ')
-		}
-
-	case e.lastType == messageOpen && next != messageClose:
-		e.indents = append(e.indents, e.indent...)
-		e.out = append(e.out, '\n')
-		e.out = append(e.out, e.indents...)
-
-	case e.lastType&(scalar|messageClose) != 0:
-		if next == messageClose {
-			e.indents = e.indents[:len(e.indents)-len(e.indent)]
-		}
-		e.out = append(e.out, '\n')
-		e.out = append(e.out, e.indents...)
-	}
-}
-
-// Snapshot returns the current snapshot for use in Reset.
-func (e *Encoder) Snapshot() encoderState {
-	return e.encoderState
-}
-
-// Reset resets the Encoder to the given encoderState from a Snapshot.
-func (e *Encoder) Reset(es encoderState) {
-	e.encoderState = es
-}
diff --git a/vendor/google.golang.org/protobuf/internal/errors/errors.go b/vendor/google.golang.org/protobuf/internal/errors/errors.go
deleted file mode 100644
index 20c17b3..0000000
--- a/vendor/google.golang.org/protobuf/internal/errors/errors.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package errors implements functions to manipulate errors.
-package errors
-
-import (
-	"errors"
-	"fmt"
-
-	"google.golang.org/protobuf/internal/detrand"
-)
-
-// Error is a sentinel matching all errors produced by this package.
-var Error = errors.New("protobuf error")
-
-// New formats a string according to the format specifier and arguments and
-// returns an error that has a "proto" prefix.
-func New(f string, x ...interface{}) error {
-	return &prefixError{s: format(f, x...)}
-}
-
-type prefixError struct{ s string }
-
-var prefix = func() string {
-	// Deliberately introduce instability into the error message string to
-	// discourage users from performing error string comparisons.
-	if detrand.Bool() {
-		return "proto: " // use non-breaking spaces (U+00a0)
-	} else {
-		return "proto: " // use regular spaces (U+0020)
-	}
-}()
-
-func (e *prefixError) Error() string {
-	return prefix + e.s
-}
-
-func (e *prefixError) Unwrap() error {
-	return Error
-}
-
-// Wrap returns an error that has a "proto" prefix, the formatted string described
-// by the format specifier and arguments, and a suffix of err. The error wraps err.
-func Wrap(err error, f string, x ...interface{}) error {
-	return &wrapError{
-		s:   format(f, x...),
-		err: err,
-	}
-}
-
-type wrapError struct {
-	s   string
-	err error
-}
-
-func (e *wrapError) Error() string {
-	return format("%v%v: %v", prefix, e.s, e.err)
-}
-
-func (e *wrapError) Unwrap() error {
-	return e.err
-}
-
-func (e *wrapError) Is(target error) bool {
-	return target == Error
-}
-
-func format(f string, x ...interface{}) string {
-	// avoid "proto: " prefix when chaining
-	for i := 0; i < len(x); i++ {
-		switch e := x[i].(type) {
-		case *prefixError:
-			x[i] = e.s
-		case *wrapError:
-			x[i] = format("%v: %v", e.s, e.err)
-		}
-	}
-	return fmt.Sprintf(f, x...)
-}
-
-func InvalidUTF8(name string) error {
-	return New("field %v contains invalid UTF-8", name)
-}
-
-func RequiredNotSet(name string) error {
-	return New("required field %v not set", name)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/errors/is_go112.go b/vendor/google.golang.org/protobuf/internal/errors/is_go112.go
deleted file mode 100644
index f90e909..0000000
--- a/vendor/google.golang.org/protobuf/internal/errors/is_go112.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !go1.13
-
-package errors
-
-import "reflect"
-
-// Is is a copy of Go 1.13's errors.Is for use with older Go versions.
-func Is(err, target error) bool {
-	if target == nil {
-		return err == target
-	}
-
-	isComparable := reflect.TypeOf(target).Comparable()
-	for {
-		if isComparable && err == target {
-			return true
-		}
-		if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
-			return true
-		}
-		if err = unwrap(err); err == nil {
-			return false
-		}
-	}
-}
-
-func unwrap(err error) error {
-	u, ok := err.(interface {
-		Unwrap() error
-	})
-	if !ok {
-		return nil
-	}
-	return u.Unwrap()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/errors/is_go113.go b/vendor/google.golang.org/protobuf/internal/errors/is_go113.go
deleted file mode 100644
index dc05f41..0000000
--- a/vendor/google.golang.org/protobuf/internal/errors/is_go113.go
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.13
-
-package errors
-
-import "errors"
-
-// Is is errors.Is.
-func Is(err, target error) bool { return errors.Is(err, target) }
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/any_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/any_gen.go
deleted file mode 100644
index 74c5fef..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/any_gen.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Any.
-const (
-	Any_TypeUrl = 1 // optional string
-	Any_Value   = 2 // optional bytes
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/api_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/api_gen.go
deleted file mode 100644
index 9a6b5f2..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/api_gen.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Api.
-const (
-	Api_Name          = 1 // optional string
-	Api_Methods       = 2 // repeated google.protobuf.Method
-	Api_Options       = 3 // repeated google.protobuf.Option
-	Api_Version       = 4 // optional string
-	Api_SourceContext = 5 // optional google.protobuf.SourceContext
-	Api_Mixins        = 6 // repeated google.protobuf.Mixin
-	Api_Syntax        = 7 // optional google.protobuf.Syntax
-)
-
-// Field numbers for google.protobuf.Method.
-const (
-	Method_Name              = 1 // optional string
-	Method_RequestTypeUrl    = 2 // optional string
-	Method_RequestStreaming  = 3 // optional bool
-	Method_ResponseTypeUrl   = 4 // optional string
-	Method_ResponseStreaming = 5 // optional bool
-	Method_Options           = 6 // repeated google.protobuf.Option
-	Method_Syntax            = 7 // optional google.protobuf.Syntax
-)
-
-// Field numbers for google.protobuf.Mixin.
-const (
-	Mixin_Name = 1 // optional string
-	Mixin_Root = 2 // optional string
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/descriptor_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/descriptor_gen.go
deleted file mode 100644
index 6e37b59..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/descriptor_gen.go
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.FileDescriptorSet.
-const (
-	FileDescriptorSet_File = 1 // repeated google.protobuf.FileDescriptorProto
-)
-
-// Field numbers for google.protobuf.FileDescriptorProto.
-const (
-	FileDescriptorProto_Name             = 1  // optional string
-	FileDescriptorProto_Package          = 2  // optional string
-	FileDescriptorProto_Dependency       = 3  // repeated string
-	FileDescriptorProto_PublicDependency = 10 // repeated int32
-	FileDescriptorProto_WeakDependency   = 11 // repeated int32
-	FileDescriptorProto_MessageType      = 4  // repeated google.protobuf.DescriptorProto
-	FileDescriptorProto_EnumType         = 5  // repeated google.protobuf.EnumDescriptorProto
-	FileDescriptorProto_Service          = 6  // repeated google.protobuf.ServiceDescriptorProto
-	FileDescriptorProto_Extension        = 7  // repeated google.protobuf.FieldDescriptorProto
-	FileDescriptorProto_Options          = 8  // optional google.protobuf.FileOptions
-	FileDescriptorProto_SourceCodeInfo   = 9  // optional google.protobuf.SourceCodeInfo
-	FileDescriptorProto_Syntax           = 12 // optional string
-)
-
-// Field numbers for google.protobuf.DescriptorProto.
-const (
-	DescriptorProto_Name           = 1  // optional string
-	DescriptorProto_Field          = 2  // repeated google.protobuf.FieldDescriptorProto
-	DescriptorProto_Extension      = 6  // repeated google.protobuf.FieldDescriptorProto
-	DescriptorProto_NestedType     = 3  // repeated google.protobuf.DescriptorProto
-	DescriptorProto_EnumType       = 4  // repeated google.protobuf.EnumDescriptorProto
-	DescriptorProto_ExtensionRange = 5  // repeated google.protobuf.DescriptorProto.ExtensionRange
-	DescriptorProto_OneofDecl      = 8  // repeated google.protobuf.OneofDescriptorProto
-	DescriptorProto_Options        = 7  // optional google.protobuf.MessageOptions
-	DescriptorProto_ReservedRange  = 9  // repeated google.protobuf.DescriptorProto.ReservedRange
-	DescriptorProto_ReservedName   = 10 // repeated string
-)
-
-// Field numbers for google.protobuf.DescriptorProto.ExtensionRange.
-const (
-	DescriptorProto_ExtensionRange_Start   = 1 // optional int32
-	DescriptorProto_ExtensionRange_End     = 2 // optional int32
-	DescriptorProto_ExtensionRange_Options = 3 // optional google.protobuf.ExtensionRangeOptions
-)
-
-// Field numbers for google.protobuf.DescriptorProto.ReservedRange.
-const (
-	DescriptorProto_ReservedRange_Start = 1 // optional int32
-	DescriptorProto_ReservedRange_End   = 2 // optional int32
-)
-
-// Field numbers for google.protobuf.ExtensionRangeOptions.
-const (
-	ExtensionRangeOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.FieldDescriptorProto.
-const (
-	FieldDescriptorProto_Name           = 1  // optional string
-	FieldDescriptorProto_Number         = 3  // optional int32
-	FieldDescriptorProto_Label          = 4  // optional google.protobuf.FieldDescriptorProto.Label
-	FieldDescriptorProto_Type           = 5  // optional google.protobuf.FieldDescriptorProto.Type
-	FieldDescriptorProto_TypeName       = 6  // optional string
-	FieldDescriptorProto_Extendee       = 2  // optional string
-	FieldDescriptorProto_DefaultValue   = 7  // optional string
-	FieldDescriptorProto_OneofIndex     = 9  // optional int32
-	FieldDescriptorProto_JsonName       = 10 // optional string
-	FieldDescriptorProto_Options        = 8  // optional google.protobuf.FieldOptions
-	FieldDescriptorProto_Proto3Optional = 17 // optional bool
-)
-
-// Field numbers for google.protobuf.OneofDescriptorProto.
-const (
-	OneofDescriptorProto_Name    = 1 // optional string
-	OneofDescriptorProto_Options = 2 // optional google.protobuf.OneofOptions
-)
-
-// Field numbers for google.protobuf.EnumDescriptorProto.
-const (
-	EnumDescriptorProto_Name          = 1 // optional string
-	EnumDescriptorProto_Value         = 2 // repeated google.protobuf.EnumValueDescriptorProto
-	EnumDescriptorProto_Options       = 3 // optional google.protobuf.EnumOptions
-	EnumDescriptorProto_ReservedRange = 4 // repeated google.protobuf.EnumDescriptorProto.EnumReservedRange
-	EnumDescriptorProto_ReservedName  = 5 // repeated string
-)
-
-// Field numbers for google.protobuf.EnumDescriptorProto.EnumReservedRange.
-const (
-	EnumDescriptorProto_EnumReservedRange_Start = 1 // optional int32
-	EnumDescriptorProto_EnumReservedRange_End   = 2 // optional int32
-)
-
-// Field numbers for google.protobuf.EnumValueDescriptorProto.
-const (
-	EnumValueDescriptorProto_Name    = 1 // optional string
-	EnumValueDescriptorProto_Number  = 2 // optional int32
-	EnumValueDescriptorProto_Options = 3 // optional google.protobuf.EnumValueOptions
-)
-
-// Field numbers for google.protobuf.ServiceDescriptorProto.
-const (
-	ServiceDescriptorProto_Name    = 1 // optional string
-	ServiceDescriptorProto_Method  = 2 // repeated google.protobuf.MethodDescriptorProto
-	ServiceDescriptorProto_Options = 3 // optional google.protobuf.ServiceOptions
-)
-
-// Field numbers for google.protobuf.MethodDescriptorProto.
-const (
-	MethodDescriptorProto_Name            = 1 // optional string
-	MethodDescriptorProto_InputType       = 2 // optional string
-	MethodDescriptorProto_OutputType      = 3 // optional string
-	MethodDescriptorProto_Options         = 4 // optional google.protobuf.MethodOptions
-	MethodDescriptorProto_ClientStreaming = 5 // optional bool
-	MethodDescriptorProto_ServerStreaming = 6 // optional bool
-)
-
-// Field numbers for google.protobuf.FileOptions.
-const (
-	FileOptions_JavaPackage               = 1   // optional string
-	FileOptions_JavaOuterClassname        = 8   // optional string
-	FileOptions_JavaMultipleFiles         = 10  // optional bool
-	FileOptions_JavaGenerateEqualsAndHash = 20  // optional bool
-	FileOptions_JavaStringCheckUtf8       = 27  // optional bool
-	FileOptions_OptimizeFor               = 9   // optional google.protobuf.FileOptions.OptimizeMode
-	FileOptions_GoPackage                 = 11  // optional string
-	FileOptions_CcGenericServices         = 16  // optional bool
-	FileOptions_JavaGenericServices       = 17  // optional bool
-	FileOptions_PyGenericServices         = 18  // optional bool
-	FileOptions_PhpGenericServices        = 42  // optional bool
-	FileOptions_Deprecated                = 23  // optional bool
-	FileOptions_CcEnableArenas            = 31  // optional bool
-	FileOptions_ObjcClassPrefix           = 36  // optional string
-	FileOptions_CsharpNamespace           = 37  // optional string
-	FileOptions_SwiftPrefix               = 39  // optional string
-	FileOptions_PhpClassPrefix            = 40  // optional string
-	FileOptions_PhpNamespace              = 41  // optional string
-	FileOptions_PhpMetadataNamespace      = 44  // optional string
-	FileOptions_RubyPackage               = 45  // optional string
-	FileOptions_UninterpretedOption       = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.MessageOptions.
-const (
-	MessageOptions_MessageSetWireFormat         = 1   // optional bool
-	MessageOptions_NoStandardDescriptorAccessor = 2   // optional bool
-	MessageOptions_Deprecated                   = 3   // optional bool
-	MessageOptions_MapEntry                     = 7   // optional bool
-	MessageOptions_UninterpretedOption          = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.FieldOptions.
-const (
-	FieldOptions_Ctype               = 1   // optional google.protobuf.FieldOptions.CType
-	FieldOptions_Packed              = 2   // optional bool
-	FieldOptions_Jstype              = 6   // optional google.protobuf.FieldOptions.JSType
-	FieldOptions_Lazy                = 5   // optional bool
-	FieldOptions_Deprecated          = 3   // optional bool
-	FieldOptions_Weak                = 10  // optional bool
-	FieldOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.OneofOptions.
-const (
-	OneofOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.EnumOptions.
-const (
-	EnumOptions_AllowAlias          = 2   // optional bool
-	EnumOptions_Deprecated          = 3   // optional bool
-	EnumOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.EnumValueOptions.
-const (
-	EnumValueOptions_Deprecated          = 1   // optional bool
-	EnumValueOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.ServiceOptions.
-const (
-	ServiceOptions_Deprecated          = 33  // optional bool
-	ServiceOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.MethodOptions.
-const (
-	MethodOptions_Deprecated          = 33  // optional bool
-	MethodOptions_IdempotencyLevel    = 34  // optional google.protobuf.MethodOptions.IdempotencyLevel
-	MethodOptions_UninterpretedOption = 999 // repeated google.protobuf.UninterpretedOption
-)
-
-// Field numbers for google.protobuf.UninterpretedOption.
-const (
-	UninterpretedOption_Name             = 2 // repeated google.protobuf.UninterpretedOption.NamePart
-	UninterpretedOption_IdentifierValue  = 3 // optional string
-	UninterpretedOption_PositiveIntValue = 4 // optional uint64
-	UninterpretedOption_NegativeIntValue = 5 // optional int64
-	UninterpretedOption_DoubleValue      = 6 // optional double
-	UninterpretedOption_StringValue      = 7 // optional bytes
-	UninterpretedOption_AggregateValue   = 8 // optional string
-)
-
-// Field numbers for google.protobuf.UninterpretedOption.NamePart.
-const (
-	UninterpretedOption_NamePart_NamePart    = 1 // required string
-	UninterpretedOption_NamePart_IsExtension = 2 // required bool
-)
-
-// Field numbers for google.protobuf.SourceCodeInfo.
-const (
-	SourceCodeInfo_Location = 1 // repeated google.protobuf.SourceCodeInfo.Location
-)
-
-// Field numbers for google.protobuf.SourceCodeInfo.Location.
-const (
-	SourceCodeInfo_Location_Path                    = 1 // repeated int32
-	SourceCodeInfo_Location_Span                    = 2 // repeated int32
-	SourceCodeInfo_Location_LeadingComments         = 3 // optional string
-	SourceCodeInfo_Location_TrailingComments        = 4 // optional string
-	SourceCodeInfo_Location_LeadingDetachedComments = 6 // repeated string
-)
-
-// Field numbers for google.protobuf.GeneratedCodeInfo.
-const (
-	GeneratedCodeInfo_Annotation = 1 // repeated google.protobuf.GeneratedCodeInfo.Annotation
-)
-
-// Field numbers for google.protobuf.GeneratedCodeInfo.Annotation.
-const (
-	GeneratedCodeInfo_Annotation_Path       = 1 // repeated int32
-	GeneratedCodeInfo_Annotation_SourceFile = 2 // optional string
-	GeneratedCodeInfo_Annotation_Begin      = 3 // optional int32
-	GeneratedCodeInfo_Annotation_End        = 4 // optional int32
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/doc.go b/vendor/google.golang.org/protobuf/internal/fieldnum/doc.go
deleted file mode 100644
index e597885..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/doc.go
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package fieldnum contains constants for field numbers of fields in messages
-// declared in descriptor.proto and any of the well-known types.
-package fieldnum
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/duration_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/duration_gen.go
deleted file mode 100644
index 8816c73..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/duration_gen.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Duration.
-const (
-	Duration_Seconds = 1 // optional int64
-	Duration_Nanos   = 2 // optional int32
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/empty_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/empty_gen.go
deleted file mode 100644
index b5130a6..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/empty_gen.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Empty.
-const ()
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/field_mask_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/field_mask_gen.go
deleted file mode 100644
index 7e3bfa2..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/field_mask_gen.go
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.FieldMask.
-const (
-	FieldMask_Paths = 1 // repeated string
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/source_context_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/source_context_gen.go
deleted file mode 100644
index 241972b..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/source_context_gen.go
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.SourceContext.
-const (
-	SourceContext_FileName = 1 // optional string
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/struct_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/struct_gen.go
deleted file mode 100644
index c460aab..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/struct_gen.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Struct.
-const (
-	Struct_Fields = 1 // repeated google.protobuf.Struct.FieldsEntry
-)
-
-// Field numbers for google.protobuf.Struct.FieldsEntry.
-const (
-	Struct_FieldsEntry_Key   = 1 // optional string
-	Struct_FieldsEntry_Value = 2 // optional google.protobuf.Value
-)
-
-// Field numbers for google.protobuf.Value.
-const (
-	Value_NullValue   = 1 // optional google.protobuf.NullValue
-	Value_NumberValue = 2 // optional double
-	Value_StringValue = 3 // optional string
-	Value_BoolValue   = 4 // optional bool
-	Value_StructValue = 5 // optional google.protobuf.Struct
-	Value_ListValue   = 6 // optional google.protobuf.ListValue
-)
-
-// Field numbers for google.protobuf.ListValue.
-const (
-	ListValue_Values = 1 // repeated google.protobuf.Value
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/timestamp_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/timestamp_gen.go
deleted file mode 100644
index b4346fb..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/timestamp_gen.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Timestamp.
-const (
-	Timestamp_Seconds = 1 // optional int64
-	Timestamp_Nanos   = 2 // optional int32
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/type_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/type_gen.go
deleted file mode 100644
index b392e95..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/type_gen.go
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.Type.
-const (
-	Type_Name          = 1 // optional string
-	Type_Fields        = 2 // repeated google.protobuf.Field
-	Type_Oneofs        = 3 // repeated string
-	Type_Options       = 4 // repeated google.protobuf.Option
-	Type_SourceContext = 5 // optional google.protobuf.SourceContext
-	Type_Syntax        = 6 // optional google.protobuf.Syntax
-)
-
-// Field numbers for google.protobuf.Field.
-const (
-	Field_Kind         = 1  // optional google.protobuf.Field.Kind
-	Field_Cardinality  = 2  // optional google.protobuf.Field.Cardinality
-	Field_Number       = 3  // optional int32
-	Field_Name         = 4  // optional string
-	Field_TypeUrl      = 6  // optional string
-	Field_OneofIndex   = 7  // optional int32
-	Field_Packed       = 8  // optional bool
-	Field_Options      = 9  // repeated google.protobuf.Option
-	Field_JsonName     = 10 // optional string
-	Field_DefaultValue = 11 // optional string
-)
-
-// Field numbers for google.protobuf.Enum.
-const (
-	Enum_Name          = 1 // optional string
-	Enum_Enumvalue     = 2 // repeated google.protobuf.EnumValue
-	Enum_Options       = 3 // repeated google.protobuf.Option
-	Enum_SourceContext = 4 // optional google.protobuf.SourceContext
-	Enum_Syntax        = 5 // optional google.protobuf.Syntax
-)
-
-// Field numbers for google.protobuf.EnumValue.
-const (
-	EnumValue_Name    = 1 // optional string
-	EnumValue_Number  = 2 // optional int32
-	EnumValue_Options = 3 // repeated google.protobuf.Option
-)
-
-// Field numbers for google.protobuf.Option.
-const (
-	Option_Name  = 1 // optional string
-	Option_Value = 2 // optional google.protobuf.Any
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldnum/wrappers_gen.go b/vendor/google.golang.org/protobuf/internal/fieldnum/wrappers_gen.go
deleted file mode 100644
index 42f846a..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldnum/wrappers_gen.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-protos. DO NOT EDIT.
-
-package fieldnum
-
-// Field numbers for google.protobuf.DoubleValue.
-const (
-	DoubleValue_Value = 1 // optional double
-)
-
-// Field numbers for google.protobuf.FloatValue.
-const (
-	FloatValue_Value = 1 // optional float
-)
-
-// Field numbers for google.protobuf.Int64Value.
-const (
-	Int64Value_Value = 1 // optional int64
-)
-
-// Field numbers for google.protobuf.UInt64Value.
-const (
-	UInt64Value_Value = 1 // optional uint64
-)
-
-// Field numbers for google.protobuf.Int32Value.
-const (
-	Int32Value_Value = 1 // optional int32
-)
-
-// Field numbers for google.protobuf.UInt32Value.
-const (
-	UInt32Value_Value = 1 // optional uint32
-)
-
-// Field numbers for google.protobuf.BoolValue.
-const (
-	BoolValue_Value = 1 // optional bool
-)
-
-// Field numbers for google.protobuf.StringValue.
-const (
-	StringValue_Value = 1 // optional string
-)
-
-// Field numbers for google.protobuf.BytesValue.
-const (
-	BytesValue_Value = 1 // optional bytes
-)
diff --git a/vendor/google.golang.org/protobuf/internal/fieldsort/fieldsort.go b/vendor/google.golang.org/protobuf/internal/fieldsort/fieldsort.go
deleted file mode 100644
index 517c4e2..0000000
--- a/vendor/google.golang.org/protobuf/internal/fieldsort/fieldsort.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package fieldsort defines an ordering of fields.
-//
-// The ordering defined by this package matches the historic behavior of the proto
-// package, placing extensions first and oneofs last.
-//
-// There is no guarantee about stability of the wire encoding, and users should not
-// depend on the order defined in this package as it is subject to change without
-// notice.
-package fieldsort
-
-import (
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Less returns true if field a comes before field j in ordered wire marshal output.
-func Less(a, b protoreflect.FieldDescriptor) bool {
-	ea := a.IsExtension()
-	eb := b.IsExtension()
-	oa := a.ContainingOneof()
-	ob := b.ContainingOneof()
-	switch {
-	case ea != eb:
-		return ea
-	case oa != nil && ob != nil:
-		if oa == ob {
-			return a.Number() < b.Number()
-		}
-		return oa.Index() < ob.Index()
-	case oa != nil && !oa.IsSynthetic():
-		return false
-	case ob != nil && !ob.IsSynthetic():
-		return true
-	default:
-		return a.Number() < b.Number()
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/build.go b/vendor/google.golang.org/protobuf/internal/filedesc/build.go
deleted file mode 100644
index 462d384..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/build.go
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package filedesc provides functionality for constructing descriptors.
-package filedesc
-
-import (
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/fieldnum"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// Builder construct a protoreflect.FileDescriptor from the raw descriptor.
-type Builder struct {
-	// GoPackagePath is the Go package path that is invoking this builder.
-	GoPackagePath string
-
-	// RawDescriptor is the wire-encoded bytes of FileDescriptorProto
-	// and must be populated.
-	RawDescriptor []byte
-
-	// NumEnums is the total number of enums declared in the file.
-	NumEnums int32
-	// NumMessages is the total number of messages declared in the file.
-	// It includes the implicit message declarations for map entries.
-	NumMessages int32
-	// NumExtensions is the total number of extensions declared in the file.
-	NumExtensions int32
-	// NumServices is the total number of services declared in the file.
-	NumServices int32
-
-	// TypeResolver resolves extension field types for descriptor options.
-	// If nil, it uses protoregistry.GlobalTypes.
-	TypeResolver interface {
-		preg.ExtensionTypeResolver
-	}
-
-	// FileRegistry is use to lookup file, enum, and message dependencies.
-	// Once constructed, the file descriptor is registered here.
-	// If nil, it uses protoregistry.GlobalFiles.
-	FileRegistry interface {
-		FindFileByPath(string) (protoreflect.FileDescriptor, error)
-		FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
-		RegisterFile(pref.FileDescriptor) error
-	}
-}
-
-// resolverByIndex is an interface Builder.FileRegistry may implement.
-// If so, it permits looking up an enum or message dependency based on the
-// sub-list and element index into filetype.Builder.DependencyIndexes.
-type resolverByIndex interface {
-	FindEnumByIndex(int32, int32, []Enum, []Message) pref.EnumDescriptor
-	FindMessageByIndex(int32, int32, []Enum, []Message) pref.MessageDescriptor
-}
-
-// Indexes of each sub-list in filetype.Builder.DependencyIndexes.
-const (
-	listFieldDeps int32 = iota
-	listExtTargets
-	listExtDeps
-	listMethInDeps
-	listMethOutDeps
-)
-
-// Out is the output of the Builder.
-type Out struct {
-	File pref.FileDescriptor
-
-	// Enums is all enum descriptors in "flattened ordering".
-	Enums []Enum
-	// Messages is all message descriptors in "flattened ordering".
-	// It includes the implicit message declarations for map entries.
-	Messages []Message
-	// Extensions is all extension descriptors in "flattened ordering".
-	Extensions []Extension
-	// Service is all service descriptors in "flattened ordering".
-	Services []Service
-}
-
-// Build constructs a FileDescriptor given the parameters set in Builder.
-// It assumes that the inputs are well-formed and panics if any inconsistencies
-// are encountered.
-//
-// If NumEnums+NumMessages+NumExtensions+NumServices is zero,
-// then Build automatically derives them from the raw descriptor.
-func (db Builder) Build() (out Out) {
-	// Populate the counts if uninitialized.
-	if db.NumEnums+db.NumMessages+db.NumExtensions+db.NumServices == 0 {
-		db.unmarshalCounts(db.RawDescriptor, true)
-	}
-
-	// Initialize resolvers and registries if unpopulated.
-	if db.TypeResolver == nil {
-		db.TypeResolver = preg.GlobalTypes
-	}
-	if db.FileRegistry == nil {
-		db.FileRegistry = preg.GlobalFiles
-	}
-
-	fd := newRawFile(db)
-	out.File = fd
-	out.Enums = fd.allEnums
-	out.Messages = fd.allMessages
-	out.Extensions = fd.allExtensions
-	out.Services = fd.allServices
-
-	if err := db.FileRegistry.RegisterFile(fd); err != nil {
-		panic(err)
-	}
-	return out
-}
-
-// unmarshalCounts counts the number of enum, message, extension, and service
-// declarations in the raw message, which is either a FileDescriptorProto
-// or a MessageDescriptorProto depending on whether isFile is set.
-func (db *Builder) unmarshalCounts(b []byte, isFile bool) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			if isFile {
-				switch num {
-				case fieldnum.FileDescriptorProto_EnumType:
-					db.NumEnums++
-				case fieldnum.FileDescriptorProto_MessageType:
-					db.unmarshalCounts(v, false)
-					db.NumMessages++
-				case fieldnum.FileDescriptorProto_Extension:
-					db.NumExtensions++
-				case fieldnum.FileDescriptorProto_Service:
-					db.NumServices++
-				}
-			} else {
-				switch num {
-				case fieldnum.DescriptorProto_EnumType:
-					db.NumEnums++
-				case fieldnum.DescriptorProto_NestedType:
-					db.unmarshalCounts(v, false)
-					db.NumMessages++
-				case fieldnum.DescriptorProto_Extension:
-					db.NumExtensions++
-				}
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc.go
deleted file mode 100644
index 2540bef..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc.go
+++ /dev/null
@@ -1,613 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package filedesc
-
-import (
-	"bytes"
-	"fmt"
-	"sync"
-	"sync/atomic"
-
-	"google.golang.org/protobuf/internal/descfmt"
-	"google.golang.org/protobuf/internal/descopts"
-	"google.golang.org/protobuf/internal/encoding/defval"
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/internal/strs"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// The types in this file may have a suffix:
-//	• L0: Contains fields common to all descriptors (except File) and
-//	must be initialized up front.
-//	• L1: Contains fields specific to a descriptor and
-//	must be initialized up front.
-//	• L2: Contains fields that are lazily initialized when constructing
-//	from the raw file descriptor. When constructing as a literal, the L2
-//	fields must be initialized up front.
-//
-// The types are exported so that packages like reflect/protodesc can
-// directly construct descriptors.
-
-type (
-	File struct {
-		fileRaw
-		L1 FileL1
-
-		once uint32     // atomically set if L2 is valid
-		mu   sync.Mutex // protects L2
-		L2   *FileL2
-	}
-	FileL1 struct {
-		Syntax  pref.Syntax
-		Path    string
-		Package pref.FullName
-
-		Enums      Enums
-		Messages   Messages
-		Extensions Extensions
-		Services   Services
-	}
-	FileL2 struct {
-		Options   func() pref.ProtoMessage
-		Imports   FileImports
-		Locations SourceLocations
-	}
-)
-
-func (fd *File) ParentFile() pref.FileDescriptor { return fd }
-func (fd *File) Parent() pref.Descriptor         { return nil }
-func (fd *File) Index() int                      { return 0 }
-func (fd *File) Syntax() pref.Syntax             { return fd.L1.Syntax }
-func (fd *File) Name() pref.Name                 { return fd.L1.Package.Name() }
-func (fd *File) FullName() pref.FullName         { return fd.L1.Package }
-func (fd *File) IsPlaceholder() bool             { return false }
-func (fd *File) Options() pref.ProtoMessage {
-	if f := fd.lazyInit().Options; f != nil {
-		return f()
-	}
-	return descopts.File
-}
-func (fd *File) Path() string                          { return fd.L1.Path }
-func (fd *File) Package() pref.FullName                { return fd.L1.Package }
-func (fd *File) Imports() pref.FileImports             { return &fd.lazyInit().Imports }
-func (fd *File) Enums() pref.EnumDescriptors           { return &fd.L1.Enums }
-func (fd *File) Messages() pref.MessageDescriptors     { return &fd.L1.Messages }
-func (fd *File) Extensions() pref.ExtensionDescriptors { return &fd.L1.Extensions }
-func (fd *File) Services() pref.ServiceDescriptors     { return &fd.L1.Services }
-func (fd *File) SourceLocations() pref.SourceLocations { return &fd.lazyInit().Locations }
-func (fd *File) Format(s fmt.State, r rune)            { descfmt.FormatDesc(s, r, fd) }
-func (fd *File) ProtoType(pref.FileDescriptor)         {}
-func (fd *File) ProtoInternal(pragma.DoNotImplement)   {}
-
-func (fd *File) lazyInit() *FileL2 {
-	if atomic.LoadUint32(&fd.once) == 0 {
-		fd.lazyInitOnce()
-	}
-	return fd.L2
-}
-
-func (fd *File) lazyInitOnce() {
-	fd.mu.Lock()
-	if fd.L2 == nil {
-		fd.lazyRawInit() // recursively initializes all L2 structures
-	}
-	atomic.StoreUint32(&fd.once, 1)
-	fd.mu.Unlock()
-}
-
-// ProtoLegacyRawDesc is a pseudo-internal API for allowing the v1 code
-// to be able to retrieve the raw descriptor.
-//
-// WARNING: This method is exempt from the compatibility promise and may be
-// removed in the future without warning.
-func (fd *File) ProtoLegacyRawDesc() []byte {
-	return fd.builder.RawDescriptor
-}
-
-// GoPackagePath is a pseudo-internal API for determining the Go package path
-// that this file descriptor is declared in.
-//
-// WARNING: This method is exempt from the compatibility promise and may be
-// removed in the future without warning.
-func (fd *File) GoPackagePath() string {
-	return fd.builder.GoPackagePath
-}
-
-type (
-	Enum struct {
-		Base
-		L1 EnumL1
-		L2 *EnumL2 // protected by fileDesc.once
-	}
-	EnumL1 struct {
-		eagerValues bool // controls whether EnumL2.Values is already populated
-	}
-	EnumL2 struct {
-		Options        func() pref.ProtoMessage
-		Values         EnumValues
-		ReservedNames  Names
-		ReservedRanges EnumRanges
-	}
-
-	EnumValue struct {
-		Base
-		L1 EnumValueL1
-	}
-	EnumValueL1 struct {
-		Options func() pref.ProtoMessage
-		Number  pref.EnumNumber
-	}
-)
-
-func (ed *Enum) Options() pref.ProtoMessage {
-	if f := ed.lazyInit().Options; f != nil {
-		return f()
-	}
-	return descopts.Enum
-}
-func (ed *Enum) Values() pref.EnumValueDescriptors {
-	if ed.L1.eagerValues {
-		return &ed.L2.Values
-	}
-	return &ed.lazyInit().Values
-}
-func (ed *Enum) ReservedNames() pref.Names       { return &ed.lazyInit().ReservedNames }
-func (ed *Enum) ReservedRanges() pref.EnumRanges { return &ed.lazyInit().ReservedRanges }
-func (ed *Enum) Format(s fmt.State, r rune)      { descfmt.FormatDesc(s, r, ed) }
-func (ed *Enum) ProtoType(pref.EnumDescriptor)   {}
-func (ed *Enum) lazyInit() *EnumL2 {
-	ed.L0.ParentFile.lazyInit() // implicitly initializes L2
-	return ed.L2
-}
-
-func (ed *EnumValue) Options() pref.ProtoMessage {
-	if f := ed.L1.Options; f != nil {
-		return f()
-	}
-	return descopts.EnumValue
-}
-func (ed *EnumValue) Number() pref.EnumNumber            { return ed.L1.Number }
-func (ed *EnumValue) Format(s fmt.State, r rune)         { descfmt.FormatDesc(s, r, ed) }
-func (ed *EnumValue) ProtoType(pref.EnumValueDescriptor) {}
-
-type (
-	Message struct {
-		Base
-		L1 MessageL1
-		L2 *MessageL2 // protected by fileDesc.once
-	}
-	MessageL1 struct {
-		Enums        Enums
-		Messages     Messages
-		Extensions   Extensions
-		IsMapEntry   bool // promoted from google.protobuf.MessageOptions
-		IsMessageSet bool // promoted from google.protobuf.MessageOptions
-	}
-	MessageL2 struct {
-		Options               func() pref.ProtoMessage
-		Fields                Fields
-		Oneofs                Oneofs
-		ReservedNames         Names
-		ReservedRanges        FieldRanges
-		RequiredNumbers       FieldNumbers // must be consistent with Fields.Cardinality
-		ExtensionRanges       FieldRanges
-		ExtensionRangeOptions []func() pref.ProtoMessage // must be same length as ExtensionRanges
-	}
-
-	Field struct {
-		Base
-		L1 FieldL1
-	}
-	FieldL1 struct {
-		Options          func() pref.ProtoMessage
-		Number           pref.FieldNumber
-		Cardinality      pref.Cardinality // must be consistent with Message.RequiredNumbers
-		Kind             pref.Kind
-		JSONName         jsonName
-		IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
-		IsWeak           bool // promoted from google.protobuf.FieldOptions
-		HasPacked        bool // promoted from google.protobuf.FieldOptions
-		IsPacked         bool // promoted from google.protobuf.FieldOptions
-		HasEnforceUTF8   bool // promoted from google.protobuf.FieldOptions
-		EnforceUTF8      bool // promoted from google.protobuf.FieldOptions
-		Default          defaultValue
-		ContainingOneof  pref.OneofDescriptor // must be consistent with Message.Oneofs.Fields
-		Enum             pref.EnumDescriptor
-		Message          pref.MessageDescriptor
-	}
-
-	Oneof struct {
-		Base
-		L1 OneofL1
-	}
-	OneofL1 struct {
-		Options func() pref.ProtoMessage
-		Fields  OneofFields // must be consistent with Message.Fields.ContainingOneof
-	}
-)
-
-func (md *Message) Options() pref.ProtoMessage {
-	if f := md.lazyInit().Options; f != nil {
-		return f()
-	}
-	return descopts.Message
-}
-func (md *Message) IsMapEntry() bool                   { return md.L1.IsMapEntry }
-func (md *Message) Fields() pref.FieldDescriptors      { return &md.lazyInit().Fields }
-func (md *Message) Oneofs() pref.OneofDescriptors      { return &md.lazyInit().Oneofs }
-func (md *Message) ReservedNames() pref.Names          { return &md.lazyInit().ReservedNames }
-func (md *Message) ReservedRanges() pref.FieldRanges   { return &md.lazyInit().ReservedRanges }
-func (md *Message) RequiredNumbers() pref.FieldNumbers { return &md.lazyInit().RequiredNumbers }
-func (md *Message) ExtensionRanges() pref.FieldRanges  { return &md.lazyInit().ExtensionRanges }
-func (md *Message) ExtensionRangeOptions(i int) pref.ProtoMessage {
-	if f := md.lazyInit().ExtensionRangeOptions[i]; f != nil {
-		return f()
-	}
-	return descopts.ExtensionRange
-}
-func (md *Message) Enums() pref.EnumDescriptors           { return &md.L1.Enums }
-func (md *Message) Messages() pref.MessageDescriptors     { return &md.L1.Messages }
-func (md *Message) Extensions() pref.ExtensionDescriptors { return &md.L1.Extensions }
-func (md *Message) ProtoType(pref.MessageDescriptor)      {}
-func (md *Message) Format(s fmt.State, r rune)            { descfmt.FormatDesc(s, r, md) }
-func (md *Message) lazyInit() *MessageL2 {
-	md.L0.ParentFile.lazyInit() // implicitly initializes L2
-	return md.L2
-}
-
-// IsMessageSet is a pseudo-internal API for checking whether a message
-// should serialize in the proto1 message format.
-//
-// WARNING: This method is exempt from the compatibility promise and may be
-// removed in the future without warning.
-func (md *Message) IsMessageSet() bool {
-	return md.L1.IsMessageSet
-}
-
-func (fd *Field) Options() pref.ProtoMessage {
-	if f := fd.L1.Options; f != nil {
-		return f()
-	}
-	return descopts.Field
-}
-func (fd *Field) Number() pref.FieldNumber      { return fd.L1.Number }
-func (fd *Field) Cardinality() pref.Cardinality { return fd.L1.Cardinality }
-func (fd *Field) Kind() pref.Kind               { return fd.L1.Kind }
-func (fd *Field) HasJSONName() bool             { return fd.L1.JSONName.has }
-func (fd *Field) JSONName() string              { return fd.L1.JSONName.get(fd) }
-func (fd *Field) HasPresence() bool {
-	return fd.L1.Cardinality != pref.Repeated && (fd.L0.ParentFile.L1.Syntax == pref.Proto2 || fd.L1.Message != nil || fd.L1.ContainingOneof != nil)
-}
-func (fd *Field) HasOptionalKeyword() bool {
-	return (fd.L0.ParentFile.L1.Syntax == pref.Proto2 && fd.L1.Cardinality == pref.Optional && fd.L1.ContainingOneof == nil) || fd.L1.IsProto3Optional
-}
-func (fd *Field) IsPacked() bool {
-	if !fd.L1.HasPacked && fd.L0.ParentFile.L1.Syntax != pref.Proto2 && fd.L1.Cardinality == pref.Repeated {
-		switch fd.L1.Kind {
-		case pref.StringKind, pref.BytesKind, pref.MessageKind, pref.GroupKind:
-		default:
-			return true
-		}
-	}
-	return fd.L1.IsPacked
-}
-func (fd *Field) IsExtension() bool { return false }
-func (fd *Field) IsWeak() bool      { return fd.L1.IsWeak }
-func (fd *Field) IsList() bool      { return fd.Cardinality() == pref.Repeated && !fd.IsMap() }
-func (fd *Field) IsMap() bool       { return fd.Message() != nil && fd.Message().IsMapEntry() }
-func (fd *Field) MapKey() pref.FieldDescriptor {
-	if !fd.IsMap() {
-		return nil
-	}
-	return fd.Message().Fields().ByNumber(1)
-}
-func (fd *Field) MapValue() pref.FieldDescriptor {
-	if !fd.IsMap() {
-		return nil
-	}
-	return fd.Message().Fields().ByNumber(2)
-}
-func (fd *Field) HasDefault() bool                           { return fd.L1.Default.has }
-func (fd *Field) Default() pref.Value                        { return fd.L1.Default.get(fd) }
-func (fd *Field) DefaultEnumValue() pref.EnumValueDescriptor { return fd.L1.Default.enum }
-func (fd *Field) ContainingOneof() pref.OneofDescriptor      { return fd.L1.ContainingOneof }
-func (fd *Field) ContainingMessage() pref.MessageDescriptor {
-	return fd.L0.Parent.(pref.MessageDescriptor)
-}
-func (fd *Field) Enum() pref.EnumDescriptor {
-	return fd.L1.Enum
-}
-func (fd *Field) Message() pref.MessageDescriptor {
-	if fd.L1.IsWeak {
-		if d, _ := protoregistry.GlobalFiles.FindDescriptorByName(fd.L1.Message.FullName()); d != nil {
-			return d.(pref.MessageDescriptor)
-		}
-	}
-	return fd.L1.Message
-}
-func (fd *Field) Format(s fmt.State, r rune)     { descfmt.FormatDesc(s, r, fd) }
-func (fd *Field) ProtoType(pref.FieldDescriptor) {}
-
-// EnforceUTF8 is a pseudo-internal API to determine whether to enforce UTF-8
-// validation for the string field. This exists for Google-internal use only
-// since proto3 did not enforce UTF-8 validity prior to the open-source release.
-// If this method does not exist, the default is to enforce valid UTF-8.
-//
-// WARNING: This method is exempt from the compatibility promise and may be
-// removed in the future without warning.
-func (fd *Field) EnforceUTF8() bool {
-	if fd.L1.HasEnforceUTF8 {
-		return fd.L1.EnforceUTF8
-	}
-	return fd.L0.ParentFile.L1.Syntax == pref.Proto3
-}
-
-func (od *Oneof) IsSynthetic() bool {
-	return od.L0.ParentFile.L1.Syntax == pref.Proto3 && len(od.L1.Fields.List) == 1 && od.L1.Fields.List[0].HasOptionalKeyword()
-}
-func (od *Oneof) Options() pref.ProtoMessage {
-	if f := od.L1.Options; f != nil {
-		return f()
-	}
-	return descopts.Oneof
-}
-func (od *Oneof) Fields() pref.FieldDescriptors  { return &od.L1.Fields }
-func (od *Oneof) Format(s fmt.State, r rune)     { descfmt.FormatDesc(s, r, od) }
-func (od *Oneof) ProtoType(pref.OneofDescriptor) {}
-
-type (
-	Extension struct {
-		Base
-		L1 ExtensionL1
-		L2 *ExtensionL2 // protected by fileDesc.once
-	}
-	ExtensionL1 struct {
-		Number      pref.FieldNumber
-		Extendee    pref.MessageDescriptor
-		Cardinality pref.Cardinality
-		Kind        pref.Kind
-	}
-	ExtensionL2 struct {
-		Options          func() pref.ProtoMessage
-		JSONName         jsonName
-		IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto
-		IsPacked         bool // promoted from google.protobuf.FieldOptions
-		Default          defaultValue
-		Enum             pref.EnumDescriptor
-		Message          pref.MessageDescriptor
-	}
-)
-
-func (xd *Extension) Options() pref.ProtoMessage {
-	if f := xd.lazyInit().Options; f != nil {
-		return f()
-	}
-	return descopts.Field
-}
-func (xd *Extension) Number() pref.FieldNumber      { return xd.L1.Number }
-func (xd *Extension) Cardinality() pref.Cardinality { return xd.L1.Cardinality }
-func (xd *Extension) Kind() pref.Kind               { return xd.L1.Kind }
-func (xd *Extension) HasJSONName() bool             { return xd.lazyInit().JSONName.has }
-func (xd *Extension) JSONName() string              { return xd.lazyInit().JSONName.get(xd) }
-func (xd *Extension) HasPresence() bool             { return xd.L1.Cardinality != pref.Repeated }
-func (xd *Extension) HasOptionalKeyword() bool {
-	return (xd.L0.ParentFile.L1.Syntax == pref.Proto2 && xd.L1.Cardinality == pref.Optional) || xd.lazyInit().IsProto3Optional
-}
-func (xd *Extension) IsPacked() bool                             { return xd.lazyInit().IsPacked }
-func (xd *Extension) IsExtension() bool                          { return true }
-func (xd *Extension) IsWeak() bool                               { return false }
-func (xd *Extension) IsList() bool                               { return xd.Cardinality() == pref.Repeated }
-func (xd *Extension) IsMap() bool                                { return false }
-func (xd *Extension) MapKey() pref.FieldDescriptor               { return nil }
-func (xd *Extension) MapValue() pref.FieldDescriptor             { return nil }
-func (xd *Extension) HasDefault() bool                           { return xd.lazyInit().Default.has }
-func (xd *Extension) Default() pref.Value                        { return xd.lazyInit().Default.get(xd) }
-func (xd *Extension) DefaultEnumValue() pref.EnumValueDescriptor { return xd.lazyInit().Default.enum }
-func (xd *Extension) ContainingOneof() pref.OneofDescriptor      { return nil }
-func (xd *Extension) ContainingMessage() pref.MessageDescriptor  { return xd.L1.Extendee }
-func (xd *Extension) Enum() pref.EnumDescriptor                  { return xd.lazyInit().Enum }
-func (xd *Extension) Message() pref.MessageDescriptor            { return xd.lazyInit().Message }
-func (xd *Extension) Format(s fmt.State, r rune)                 { descfmt.FormatDesc(s, r, xd) }
-func (xd *Extension) ProtoType(pref.FieldDescriptor)             {}
-func (xd *Extension) ProtoInternal(pragma.DoNotImplement)        {}
-func (xd *Extension) lazyInit() *ExtensionL2 {
-	xd.L0.ParentFile.lazyInit() // implicitly initializes L2
-	return xd.L2
-}
-
-type (
-	Service struct {
-		Base
-		L1 ServiceL1
-		L2 *ServiceL2 // protected by fileDesc.once
-	}
-	ServiceL1 struct{}
-	ServiceL2 struct {
-		Options func() pref.ProtoMessage
-		Methods Methods
-	}
-
-	Method struct {
-		Base
-		L1 MethodL1
-	}
-	MethodL1 struct {
-		Options           func() pref.ProtoMessage
-		Input             pref.MessageDescriptor
-		Output            pref.MessageDescriptor
-		IsStreamingClient bool
-		IsStreamingServer bool
-	}
-)
-
-func (sd *Service) Options() pref.ProtoMessage {
-	if f := sd.lazyInit().Options; f != nil {
-		return f()
-	}
-	return descopts.Service
-}
-func (sd *Service) Methods() pref.MethodDescriptors     { return &sd.lazyInit().Methods }
-func (sd *Service) Format(s fmt.State, r rune)          { descfmt.FormatDesc(s, r, sd) }
-func (sd *Service) ProtoType(pref.ServiceDescriptor)    {}
-func (sd *Service) ProtoInternal(pragma.DoNotImplement) {}
-func (sd *Service) lazyInit() *ServiceL2 {
-	sd.L0.ParentFile.lazyInit() // implicitly initializes L2
-	return sd.L2
-}
-
-func (md *Method) Options() pref.ProtoMessage {
-	if f := md.L1.Options; f != nil {
-		return f()
-	}
-	return descopts.Method
-}
-func (md *Method) Input() pref.MessageDescriptor       { return md.L1.Input }
-func (md *Method) Output() pref.MessageDescriptor      { return md.L1.Output }
-func (md *Method) IsStreamingClient() bool             { return md.L1.IsStreamingClient }
-func (md *Method) IsStreamingServer() bool             { return md.L1.IsStreamingServer }
-func (md *Method) Format(s fmt.State, r rune)          { descfmt.FormatDesc(s, r, md) }
-func (md *Method) ProtoType(pref.MethodDescriptor)     {}
-func (md *Method) ProtoInternal(pragma.DoNotImplement) {}
-
-// Surrogate files are can be used to create standalone descriptors
-// where the syntax is only information derived from the parent file.
-var (
-	SurrogateProto2 = &File{L1: FileL1{Syntax: pref.Proto2}, L2: &FileL2{}}
-	SurrogateProto3 = &File{L1: FileL1{Syntax: pref.Proto3}, L2: &FileL2{}}
-)
-
-type (
-	Base struct {
-		L0 BaseL0
-	}
-	BaseL0 struct {
-		FullName   pref.FullName // must be populated
-		ParentFile *File         // must be populated
-		Parent     pref.Descriptor
-		Index      int
-	}
-)
-
-func (d *Base) Name() pref.Name         { return d.L0.FullName.Name() }
-func (d *Base) FullName() pref.FullName { return d.L0.FullName }
-func (d *Base) ParentFile() pref.FileDescriptor {
-	if d.L0.ParentFile == SurrogateProto2 || d.L0.ParentFile == SurrogateProto3 {
-		return nil // surrogate files are not real parents
-	}
-	return d.L0.ParentFile
-}
-func (d *Base) Parent() pref.Descriptor             { return d.L0.Parent }
-func (d *Base) Index() int                          { return d.L0.Index }
-func (d *Base) Syntax() pref.Syntax                 { return d.L0.ParentFile.Syntax() }
-func (d *Base) IsPlaceholder() bool                 { return false }
-func (d *Base) ProtoInternal(pragma.DoNotImplement) {}
-
-type jsonName struct {
-	has  bool
-	once sync.Once
-	name string
-}
-
-// Init initializes the name. It is exported for use by other internal packages.
-func (js *jsonName) Init(s string) {
-	js.has = true
-	js.name = s
-}
-
-func (js *jsonName) get(fd pref.FieldDescriptor) string {
-	if !js.has {
-		js.once.Do(func() {
-			js.name = strs.JSONCamelCase(string(fd.Name()))
-		})
-	}
-	return js.name
-}
-
-func DefaultValue(v pref.Value, ev pref.EnumValueDescriptor) defaultValue {
-	dv := defaultValue{has: v.IsValid(), val: v, enum: ev}
-	if b, ok := v.Interface().([]byte); ok {
-		// Store a copy of the default bytes, so that we can detect
-		// accidental mutations of the original value.
-		dv.bytes = append([]byte(nil), b...)
-	}
-	return dv
-}
-
-func unmarshalDefault(b []byte, k pref.Kind, pf *File, ed pref.EnumDescriptor) defaultValue {
-	var evs pref.EnumValueDescriptors
-	if k == pref.EnumKind {
-		// If the enum is declared within the same file, be careful not to
-		// blindly call the Values method, lest we bind ourselves in a deadlock.
-		if e, ok := ed.(*Enum); ok && e.L0.ParentFile == pf {
-			evs = &e.L2.Values
-		} else {
-			evs = ed.Values()
-		}
-
-		// If we are unable to resolve the enum dependency, use a placeholder
-		// enum value since we will not be able to parse the default value.
-		if ed.IsPlaceholder() && pref.Name(b).IsValid() {
-			v := pref.ValueOfEnum(0)
-			ev := PlaceholderEnumValue(ed.FullName().Parent().Append(pref.Name(b)))
-			return DefaultValue(v, ev)
-		}
-	}
-
-	v, ev, err := defval.Unmarshal(string(b), k, evs, defval.Descriptor)
-	if err != nil {
-		panic(err)
-	}
-	return DefaultValue(v, ev)
-}
-
-type defaultValue struct {
-	has   bool
-	val   pref.Value
-	enum  pref.EnumValueDescriptor
-	bytes []byte
-}
-
-func (dv *defaultValue) get(fd pref.FieldDescriptor) pref.Value {
-	// Return the zero value as the default if unpopulated.
-	if !dv.has {
-		if fd.Cardinality() == pref.Repeated {
-			return pref.Value{}
-		}
-		switch fd.Kind() {
-		case pref.BoolKind:
-			return pref.ValueOfBool(false)
-		case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
-			return pref.ValueOfInt32(0)
-		case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-			return pref.ValueOfInt64(0)
-		case pref.Uint32Kind, pref.Fixed32Kind:
-			return pref.ValueOfUint32(0)
-		case pref.Uint64Kind, pref.Fixed64Kind:
-			return pref.ValueOfUint64(0)
-		case pref.FloatKind:
-			return pref.ValueOfFloat32(0)
-		case pref.DoubleKind:
-			return pref.ValueOfFloat64(0)
-		case pref.StringKind:
-			return pref.ValueOfString("")
-		case pref.BytesKind:
-			return pref.ValueOfBytes(nil)
-		case pref.EnumKind:
-			if evs := fd.Enum().Values(); evs.Len() > 0 {
-				return pref.ValueOfEnum(evs.Get(0).Number())
-			}
-			return pref.ValueOfEnum(0)
-		}
-	}
-
-	if len(dv.bytes) > 0 && !bytes.Equal(dv.bytes, dv.val.Bytes()) {
-		// TODO: Avoid panic if we're running with the race detector
-		// and instead spawn a goroutine that periodically resets
-		// this value back to the original to induce a race.
-		panic(fmt.Sprintf("detected mutation on the default bytes for %v", fd.FullName()))
-	}
-	return dv.val
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go
deleted file mode 100644
index c0cddf8..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go
+++ /dev/null
@@ -1,471 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package filedesc
-
-import (
-	"sync"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/fieldnum"
-	"google.golang.org/protobuf/internal/strs"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// fileRaw is a data struct used when initializing a file descriptor from
-// a raw FileDescriptorProto.
-type fileRaw struct {
-	builder       Builder
-	allEnums      []Enum
-	allMessages   []Message
-	allExtensions []Extension
-	allServices   []Service
-}
-
-func newRawFile(db Builder) *File {
-	fd := &File{fileRaw: fileRaw{builder: db}}
-	fd.initDecls(db.NumEnums, db.NumMessages, db.NumExtensions, db.NumServices)
-	fd.unmarshalSeed(db.RawDescriptor)
-
-	// Extended message targets are eagerly resolved since registration
-	// needs this information at program init time.
-	for i := range fd.allExtensions {
-		xd := &fd.allExtensions[i]
-		xd.L1.Extendee = fd.resolveMessageDependency(xd.L1.Extendee, listExtTargets, int32(i))
-	}
-
-	fd.checkDecls()
-	return fd
-}
-
-// initDecls pre-allocates slices for the exact number of enums, messages
-// (including map entries), extensions, and services declared in the proto file.
-// This is done to avoid regrowing the slice, which would change the address
-// for any previously seen declaration.
-//
-// The alloc methods "allocates" slices by pulling from the capacity.
-func (fd *File) initDecls(numEnums, numMessages, numExtensions, numServices int32) {
-	fd.allEnums = make([]Enum, 0, numEnums)
-	fd.allMessages = make([]Message, 0, numMessages)
-	fd.allExtensions = make([]Extension, 0, numExtensions)
-	fd.allServices = make([]Service, 0, numServices)
-}
-
-func (fd *File) allocEnums(n int) []Enum {
-	total := len(fd.allEnums)
-	es := fd.allEnums[total : total+n]
-	fd.allEnums = fd.allEnums[:total+n]
-	return es
-}
-func (fd *File) allocMessages(n int) []Message {
-	total := len(fd.allMessages)
-	ms := fd.allMessages[total : total+n]
-	fd.allMessages = fd.allMessages[:total+n]
-	return ms
-}
-func (fd *File) allocExtensions(n int) []Extension {
-	total := len(fd.allExtensions)
-	xs := fd.allExtensions[total : total+n]
-	fd.allExtensions = fd.allExtensions[:total+n]
-	return xs
-}
-func (fd *File) allocServices(n int) []Service {
-	total := len(fd.allServices)
-	xs := fd.allServices[total : total+n]
-	fd.allServices = fd.allServices[:total+n]
-	return xs
-}
-
-// checkDecls performs a sanity check that the expected number of expected
-// declarations matches the number that were found in the descriptor proto.
-func (fd *File) checkDecls() {
-	switch {
-	case len(fd.allEnums) != cap(fd.allEnums):
-	case len(fd.allMessages) != cap(fd.allMessages):
-	case len(fd.allExtensions) != cap(fd.allExtensions):
-	case len(fd.allServices) != cap(fd.allServices):
-	default:
-		return
-	}
-	panic("mismatching cardinality")
-}
-
-func (fd *File) unmarshalSeed(b []byte) {
-	sb := getBuilder()
-	defer putBuilder(sb)
-
-	var prevField pref.FieldNumber
-	var numEnums, numMessages, numExtensions, numServices int
-	var posEnums, posMessages, posExtensions, posServices int
-	b0 := b
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FileDescriptorProto_Syntax:
-				switch string(v) {
-				case "proto2":
-					fd.L1.Syntax = pref.Proto2
-				case "proto3":
-					fd.L1.Syntax = pref.Proto3
-				default:
-					panic("invalid syntax")
-				}
-			case fieldnum.FileDescriptorProto_Name:
-				fd.L1.Path = sb.MakeString(v)
-			case fieldnum.FileDescriptorProto_Package:
-				fd.L1.Package = pref.FullName(sb.MakeString(v))
-			case fieldnum.FileDescriptorProto_EnumType:
-				if prevField != fieldnum.FileDescriptorProto_EnumType {
-					if numEnums > 0 {
-						panic("non-contiguous repeated field")
-					}
-					posEnums = len(b0) - len(b) - n - m
-				}
-				numEnums++
-			case fieldnum.FileDescriptorProto_MessageType:
-				if prevField != fieldnum.FileDescriptorProto_MessageType {
-					if numMessages > 0 {
-						panic("non-contiguous repeated field")
-					}
-					posMessages = len(b0) - len(b) - n - m
-				}
-				numMessages++
-			case fieldnum.FileDescriptorProto_Extension:
-				if prevField != fieldnum.FileDescriptorProto_Extension {
-					if numExtensions > 0 {
-						panic("non-contiguous repeated field")
-					}
-					posExtensions = len(b0) - len(b) - n - m
-				}
-				numExtensions++
-			case fieldnum.FileDescriptorProto_Service:
-				if prevField != fieldnum.FileDescriptorProto_Service {
-					if numServices > 0 {
-						panic("non-contiguous repeated field")
-					}
-					posServices = len(b0) - len(b) - n - m
-				}
-				numServices++
-			}
-			prevField = num
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-			prevField = -1 // ignore known field numbers of unknown wire type
-		}
-	}
-
-	// If syntax is missing, it is assumed to be proto2.
-	if fd.L1.Syntax == 0 {
-		fd.L1.Syntax = pref.Proto2
-	}
-
-	// Must allocate all declarations before parsing each descriptor type
-	// to ensure we handled all descriptors in "flattened ordering".
-	if numEnums > 0 {
-		fd.L1.Enums.List = fd.allocEnums(numEnums)
-	}
-	if numMessages > 0 {
-		fd.L1.Messages.List = fd.allocMessages(numMessages)
-	}
-	if numExtensions > 0 {
-		fd.L1.Extensions.List = fd.allocExtensions(numExtensions)
-	}
-	if numServices > 0 {
-		fd.L1.Services.List = fd.allocServices(numServices)
-	}
-
-	if numEnums > 0 {
-		b := b0[posEnums:]
-		for i := range fd.L1.Enums.List {
-			_, n := protowire.ConsumeVarint(b)
-			v, m := protowire.ConsumeBytes(b[n:])
-			fd.L1.Enums.List[i].unmarshalSeed(v, sb, fd, fd, i)
-			b = b[n+m:]
-		}
-	}
-	if numMessages > 0 {
-		b := b0[posMessages:]
-		for i := range fd.L1.Messages.List {
-			_, n := protowire.ConsumeVarint(b)
-			v, m := protowire.ConsumeBytes(b[n:])
-			fd.L1.Messages.List[i].unmarshalSeed(v, sb, fd, fd, i)
-			b = b[n+m:]
-		}
-	}
-	if numExtensions > 0 {
-		b := b0[posExtensions:]
-		for i := range fd.L1.Extensions.List {
-			_, n := protowire.ConsumeVarint(b)
-			v, m := protowire.ConsumeBytes(b[n:])
-			fd.L1.Extensions.List[i].unmarshalSeed(v, sb, fd, fd, i)
-			b = b[n+m:]
-		}
-	}
-	if numServices > 0 {
-		b := b0[posServices:]
-		for i := range fd.L1.Services.List {
-			_, n := protowire.ConsumeVarint(b)
-			v, m := protowire.ConsumeBytes(b[n:])
-			fd.L1.Services.List[i].unmarshalSeed(v, sb, fd, fd, i)
-			b = b[n+m:]
-		}
-	}
-}
-
-func (ed *Enum) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
-	ed.L0.ParentFile = pf
-	ed.L0.Parent = pd
-	ed.L0.Index = i
-
-	var numValues int
-	for b := b; len(b) > 0; {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.EnumDescriptorProto_Name:
-				ed.L0.FullName = appendFullName(sb, pd.FullName(), v)
-			case fieldnum.EnumDescriptorProto_Value:
-				numValues++
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-
-	// Only construct enum value descriptors for top-level enums since
-	// they are needed for registration.
-	if pd != pf {
-		return
-	}
-	ed.L1.eagerValues = true
-	ed.L2 = new(EnumL2)
-	ed.L2.Values.List = make([]EnumValue, numValues)
-	for i := 0; len(b) > 0; {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.EnumDescriptorProto_Value:
-				ed.L2.Values.List[i].unmarshalFull(v, sb, pf, ed, i)
-				i++
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}
-
-func (md *Message) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
-	md.L0.ParentFile = pf
-	md.L0.Parent = pd
-	md.L0.Index = i
-
-	var prevField pref.FieldNumber
-	var numEnums, numMessages, numExtensions int
-	var posEnums, posMessages, posExtensions int
-	b0 := b
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.DescriptorProto_Name:
-				md.L0.FullName = appendFullName(sb, pd.FullName(), v)
-			case fieldnum.DescriptorProto_EnumType:
-				if prevField != fieldnum.DescriptorProto_EnumType {
-					if numEnums > 0 {
-						panic("non-contiguous repeated field")
-					}
-					posEnums = len(b0) - len(b) - n - m
-				}
-				numEnums++
-			case fieldnum.DescriptorProto_NestedType:
-				if prevField != fieldnum.DescriptorProto_NestedType {
-					if numMessages > 0 {
-						panic("non-contiguous repeated field")
-					}
-					posMessages = len(b0) - len(b) - n - m
-				}
-				numMessages++
-			case fieldnum.DescriptorProto_Extension:
-				if prevField != fieldnum.DescriptorProto_Extension {
-					if numExtensions > 0 {
-						panic("non-contiguous repeated field")
-					}
-					posExtensions = len(b0) - len(b) - n - m
-				}
-				numExtensions++
-			case fieldnum.DescriptorProto_Options:
-				md.unmarshalSeedOptions(v)
-			}
-			prevField = num
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-			prevField = -1 // ignore known field numbers of unknown wire type
-		}
-	}
-
-	// Must allocate all declarations before parsing each descriptor type
-	// to ensure we handled all descriptors in "flattened ordering".
-	if numEnums > 0 {
-		md.L1.Enums.List = pf.allocEnums(numEnums)
-	}
-	if numMessages > 0 {
-		md.L1.Messages.List = pf.allocMessages(numMessages)
-	}
-	if numExtensions > 0 {
-		md.L1.Extensions.List = pf.allocExtensions(numExtensions)
-	}
-
-	if numEnums > 0 {
-		b := b0[posEnums:]
-		for i := range md.L1.Enums.List {
-			_, n := protowire.ConsumeVarint(b)
-			v, m := protowire.ConsumeBytes(b[n:])
-			md.L1.Enums.List[i].unmarshalSeed(v, sb, pf, md, i)
-			b = b[n+m:]
-		}
-	}
-	if numMessages > 0 {
-		b := b0[posMessages:]
-		for i := range md.L1.Messages.List {
-			_, n := protowire.ConsumeVarint(b)
-			v, m := protowire.ConsumeBytes(b[n:])
-			md.L1.Messages.List[i].unmarshalSeed(v, sb, pf, md, i)
-			b = b[n+m:]
-		}
-	}
-	if numExtensions > 0 {
-		b := b0[posExtensions:]
-		for i := range md.L1.Extensions.List {
-			_, n := protowire.ConsumeVarint(b)
-			v, m := protowire.ConsumeBytes(b[n:])
-			md.L1.Extensions.List[i].unmarshalSeed(v, sb, pf, md, i)
-			b = b[n+m:]
-		}
-	}
-}
-
-func (md *Message) unmarshalSeedOptions(b []byte) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.MessageOptions_MapEntry:
-				md.L1.IsMapEntry = protowire.DecodeBool(v)
-			case fieldnum.MessageOptions_MessageSetWireFormat:
-				md.L1.IsMessageSet = protowire.DecodeBool(v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}
-
-func (xd *Extension) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
-	xd.L0.ParentFile = pf
-	xd.L0.Parent = pd
-	xd.L0.Index = i
-
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FieldDescriptorProto_Number:
-				xd.L1.Number = pref.FieldNumber(v)
-			case fieldnum.FieldDescriptorProto_Label:
-				xd.L1.Cardinality = pref.Cardinality(v)
-			case fieldnum.FieldDescriptorProto_Type:
-				xd.L1.Kind = pref.Kind(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FieldDescriptorProto_Name:
-				xd.L0.FullName = appendFullName(sb, pd.FullName(), v)
-			case fieldnum.FieldDescriptorProto_Extendee:
-				xd.L1.Extendee = PlaceholderMessage(makeFullName(sb, v))
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}
-
-func (sd *Service) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
-	sd.L0.ParentFile = pf
-	sd.L0.Parent = pd
-	sd.L0.Index = i
-
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.ServiceDescriptorProto_Name:
-				sd.L0.FullName = appendFullName(sb, pd.FullName(), v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}
-
-var nameBuilderPool = sync.Pool{
-	New: func() interface{} { return new(strs.Builder) },
-}
-
-func getBuilder() *strs.Builder {
-	return nameBuilderPool.Get().(*strs.Builder)
-}
-func putBuilder(b *strs.Builder) {
-	nameBuilderPool.Put(b)
-}
-
-// makeFullName converts b to a protoreflect.FullName,
-// where b must start with a leading dot.
-func makeFullName(sb *strs.Builder, b []byte) pref.FullName {
-	if len(b) == 0 || b[0] != '.' {
-		panic("name reference must be fully qualified")
-	}
-	return pref.FullName(sb.MakeString(b[1:]))
-}
-
-func appendFullName(sb *strs.Builder, prefix pref.FullName, suffix []byte) pref.FullName {
-	return sb.AppendFullName(prefix, pref.Name(strs.UnsafeString(suffix)))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
deleted file mode 100644
index bc21594..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go
+++ /dev/null
@@ -1,704 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package filedesc
-
-import (
-	"reflect"
-	"sync"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/descopts"
-	"google.golang.org/protobuf/internal/fieldnum"
-	"google.golang.org/protobuf/internal/strs"
-	"google.golang.org/protobuf/proto"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-func (fd *File) lazyRawInit() {
-	fd.unmarshalFull(fd.builder.RawDescriptor)
-	fd.resolveMessages()
-	fd.resolveExtensions()
-	fd.resolveServices()
-}
-
-func (file *File) resolveMessages() {
-	var depIdx int32
-	for i := range file.allMessages {
-		md := &file.allMessages[i]
-
-		// Resolve message field dependencies.
-		for j := range md.L2.Fields.List {
-			fd := &md.L2.Fields.List[j]
-
-			// Weak fields are resolved upon actual use.
-			if fd.L1.IsWeak {
-				continue
-			}
-
-			// Resolve message field dependency.
-			switch fd.L1.Kind {
-			case pref.EnumKind:
-				fd.L1.Enum = file.resolveEnumDependency(fd.L1.Enum, listFieldDeps, depIdx)
-				depIdx++
-			case pref.MessageKind, pref.GroupKind:
-				fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx)
-				depIdx++
-			}
-
-			// Default is resolved here since it depends on Enum being resolved.
-			if v := fd.L1.Default.val; v.IsValid() {
-				fd.L1.Default = unmarshalDefault(v.Bytes(), fd.L1.Kind, file, fd.L1.Enum)
-			}
-		}
-	}
-}
-
-func (file *File) resolveExtensions() {
-	var depIdx int32
-	for i := range file.allExtensions {
-		xd := &file.allExtensions[i]
-
-		// Resolve extension field dependency.
-		switch xd.L1.Kind {
-		case pref.EnumKind:
-			xd.L2.Enum = file.resolveEnumDependency(xd.L2.Enum, listExtDeps, depIdx)
-			depIdx++
-		case pref.MessageKind, pref.GroupKind:
-			xd.L2.Message = file.resolveMessageDependency(xd.L2.Message, listExtDeps, depIdx)
-			depIdx++
-		}
-
-		// Default is resolved here since it depends on Enum being resolved.
-		if v := xd.L2.Default.val; v.IsValid() {
-			xd.L2.Default = unmarshalDefault(v.Bytes(), xd.L1.Kind, file, xd.L2.Enum)
-		}
-	}
-}
-
-func (file *File) resolveServices() {
-	var depIdx int32
-	for i := range file.allServices {
-		sd := &file.allServices[i]
-
-		// Resolve method dependencies.
-		for j := range sd.L2.Methods.List {
-			md := &sd.L2.Methods.List[j]
-			md.L1.Input = file.resolveMessageDependency(md.L1.Input, listMethInDeps, depIdx)
-			md.L1.Output = file.resolveMessageDependency(md.L1.Output, listMethOutDeps, depIdx)
-			depIdx++
-		}
-	}
-}
-
-func (file *File) resolveEnumDependency(ed pref.EnumDescriptor, i, j int32) pref.EnumDescriptor {
-	r := file.builder.FileRegistry
-	if r, ok := r.(resolverByIndex); ok {
-		if ed2 := r.FindEnumByIndex(i, j, file.allEnums, file.allMessages); ed2 != nil {
-			return ed2
-		}
-	}
-	for i := range file.allEnums {
-		if ed2 := &file.allEnums[i]; ed2.L0.FullName == ed.FullName() {
-			return ed2
-		}
-	}
-	if d, _ := r.FindDescriptorByName(ed.FullName()); d != nil {
-		return d.(pref.EnumDescriptor)
-	}
-	return ed
-}
-
-func (file *File) resolveMessageDependency(md pref.MessageDescriptor, i, j int32) pref.MessageDescriptor {
-	r := file.builder.FileRegistry
-	if r, ok := r.(resolverByIndex); ok {
-		if md2 := r.FindMessageByIndex(i, j, file.allEnums, file.allMessages); md2 != nil {
-			return md2
-		}
-	}
-	for i := range file.allMessages {
-		if md2 := &file.allMessages[i]; md2.L0.FullName == md.FullName() {
-			return md2
-		}
-	}
-	if d, _ := r.FindDescriptorByName(md.FullName()); d != nil {
-		return d.(pref.MessageDescriptor)
-	}
-	return md
-}
-
-func (fd *File) unmarshalFull(b []byte) {
-	sb := getBuilder()
-	defer putBuilder(sb)
-
-	var enumIdx, messageIdx, extensionIdx, serviceIdx int
-	var rawOptions []byte
-	fd.L2 = new(FileL2)
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FileDescriptorProto_PublicDependency:
-				fd.L2.Imports[v].IsPublic = true
-			case fieldnum.FileDescriptorProto_WeakDependency:
-				fd.L2.Imports[v].IsWeak = true
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FileDescriptorProto_Dependency:
-				path := sb.MakeString(v)
-				imp, _ := fd.builder.FileRegistry.FindFileByPath(path)
-				if imp == nil {
-					imp = PlaceholderFile(path)
-				}
-				fd.L2.Imports = append(fd.L2.Imports, pref.FileImport{FileDescriptor: imp})
-			case fieldnum.FileDescriptorProto_EnumType:
-				fd.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
-				enumIdx++
-			case fieldnum.FileDescriptorProto_MessageType:
-				fd.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
-				messageIdx++
-			case fieldnum.FileDescriptorProto_Extension:
-				fd.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
-				extensionIdx++
-			case fieldnum.FileDescriptorProto_Service:
-				fd.L1.Services.List[serviceIdx].unmarshalFull(v, sb)
-				serviceIdx++
-			case fieldnum.FileDescriptorProto_Options:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	fd.L2.Options = fd.builder.optionsUnmarshaler(&descopts.File, rawOptions)
-}
-
-func (ed *Enum) unmarshalFull(b []byte, sb *strs.Builder) {
-	var rawValues [][]byte
-	var rawOptions []byte
-	if !ed.L1.eagerValues {
-		ed.L2 = new(EnumL2)
-	}
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.EnumDescriptorProto_Value:
-				rawValues = append(rawValues, v)
-			case fieldnum.EnumDescriptorProto_ReservedName:
-				ed.L2.ReservedNames.List = append(ed.L2.ReservedNames.List, pref.Name(sb.MakeString(v)))
-			case fieldnum.EnumDescriptorProto_ReservedRange:
-				ed.L2.ReservedRanges.List = append(ed.L2.ReservedRanges.List, unmarshalEnumReservedRange(v))
-			case fieldnum.EnumDescriptorProto_Options:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	if !ed.L1.eagerValues && len(rawValues) > 0 {
-		ed.L2.Values.List = make([]EnumValue, len(rawValues))
-		for i, b := range rawValues {
-			ed.L2.Values.List[i].unmarshalFull(b, sb, ed.L0.ParentFile, ed, i)
-		}
-	}
-	ed.L2.Options = ed.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Enum, rawOptions)
-}
-
-func unmarshalEnumReservedRange(b []byte) (r [2]pref.EnumNumber) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.EnumDescriptorProto_EnumReservedRange_Start:
-				r[0] = pref.EnumNumber(v)
-			case fieldnum.EnumDescriptorProto_EnumReservedRange_End:
-				r[1] = pref.EnumNumber(v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	return r
-}
-
-func (vd *EnumValue) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
-	vd.L0.ParentFile = pf
-	vd.L0.Parent = pd
-	vd.L0.Index = i
-
-	var rawOptions []byte
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.EnumValueDescriptorProto_Number:
-				vd.L1.Number = pref.EnumNumber(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.EnumValueDescriptorProto_Name:
-				// NOTE: Enum values are in the same scope as the enum parent.
-				vd.L0.FullName = appendFullName(sb, pd.Parent().FullName(), v)
-			case fieldnum.EnumValueDescriptorProto_Options:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	vd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.EnumValue, rawOptions)
-}
-
-func (md *Message) unmarshalFull(b []byte, sb *strs.Builder) {
-	var rawFields, rawOneofs [][]byte
-	var enumIdx, messageIdx, extensionIdx int
-	var rawOptions []byte
-	md.L2 = new(MessageL2)
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.DescriptorProto_Field:
-				rawFields = append(rawFields, v)
-			case fieldnum.DescriptorProto_OneofDecl:
-				rawOneofs = append(rawOneofs, v)
-			case fieldnum.DescriptorProto_ReservedName:
-				md.L2.ReservedNames.List = append(md.L2.ReservedNames.List, pref.Name(sb.MakeString(v)))
-			case fieldnum.DescriptorProto_ReservedRange:
-				md.L2.ReservedRanges.List = append(md.L2.ReservedRanges.List, unmarshalMessageReservedRange(v))
-			case fieldnum.DescriptorProto_ExtensionRange:
-				r, rawOptions := unmarshalMessageExtensionRange(v)
-				opts := md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.ExtensionRange, rawOptions)
-				md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, r)
-				md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, opts)
-			case fieldnum.DescriptorProto_EnumType:
-				md.L1.Enums.List[enumIdx].unmarshalFull(v, sb)
-				enumIdx++
-			case fieldnum.DescriptorProto_NestedType:
-				md.L1.Messages.List[messageIdx].unmarshalFull(v, sb)
-				messageIdx++
-			case fieldnum.DescriptorProto_Extension:
-				md.L1.Extensions.List[extensionIdx].unmarshalFull(v, sb)
-				extensionIdx++
-			case fieldnum.DescriptorProto_Options:
-				md.unmarshalOptions(v)
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	if len(rawFields) > 0 || len(rawOneofs) > 0 {
-		md.L2.Fields.List = make([]Field, len(rawFields))
-		md.L2.Oneofs.List = make([]Oneof, len(rawOneofs))
-		for i, b := range rawFields {
-			fd := &md.L2.Fields.List[i]
-			fd.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
-			if fd.L1.Cardinality == pref.Required {
-				md.L2.RequiredNumbers.List = append(md.L2.RequiredNumbers.List, fd.L1.Number)
-			}
-		}
-		for i, b := range rawOneofs {
-			od := &md.L2.Oneofs.List[i]
-			od.unmarshalFull(b, sb, md.L0.ParentFile, md, i)
-		}
-	}
-	md.L2.Options = md.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Message, rawOptions)
-}
-
-func (md *Message) unmarshalOptions(b []byte) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.MessageOptions_MapEntry:
-				md.L1.IsMapEntry = protowire.DecodeBool(v)
-			case fieldnum.MessageOptions_MessageSetWireFormat:
-				md.L1.IsMessageSet = protowire.DecodeBool(v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}
-
-func unmarshalMessageReservedRange(b []byte) (r [2]pref.FieldNumber) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.DescriptorProto_ReservedRange_Start:
-				r[0] = pref.FieldNumber(v)
-			case fieldnum.DescriptorProto_ReservedRange_End:
-				r[1] = pref.FieldNumber(v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	return r
-}
-
-func unmarshalMessageExtensionRange(b []byte) (r [2]pref.FieldNumber, rawOptions []byte) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.DescriptorProto_ExtensionRange_Start:
-				r[0] = pref.FieldNumber(v)
-			case fieldnum.DescriptorProto_ExtensionRange_End:
-				r[1] = pref.FieldNumber(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.DescriptorProto_ExtensionRange_Options:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	return r, rawOptions
-}
-
-func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
-	fd.L0.ParentFile = pf
-	fd.L0.Parent = pd
-	fd.L0.Index = i
-
-	var rawTypeName []byte
-	var rawOptions []byte
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FieldDescriptorProto_Number:
-				fd.L1.Number = pref.FieldNumber(v)
-			case fieldnum.FieldDescriptorProto_Label:
-				fd.L1.Cardinality = pref.Cardinality(v)
-			case fieldnum.FieldDescriptorProto_Type:
-				fd.L1.Kind = pref.Kind(v)
-			case fieldnum.FieldDescriptorProto_OneofIndex:
-				// In Message.unmarshalFull, we allocate slices for both
-				// the field and oneof descriptors before unmarshaling either
-				// of them. This ensures pointers to slice elements are stable.
-				od := &pd.(*Message).L2.Oneofs.List[v]
-				od.L1.Fields.List = append(od.L1.Fields.List, fd)
-				if fd.L1.ContainingOneof != nil {
-					panic("oneof type already set")
-				}
-				fd.L1.ContainingOneof = od
-			case fieldnum.FieldDescriptorProto_Proto3Optional:
-				fd.L1.IsProto3Optional = protowire.DecodeBool(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FieldDescriptorProto_Name:
-				fd.L0.FullName = appendFullName(sb, pd.FullName(), v)
-			case fieldnum.FieldDescriptorProto_JsonName:
-				fd.L1.JSONName.Init(sb.MakeString(v))
-			case fieldnum.FieldDescriptorProto_DefaultValue:
-				fd.L1.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveMessages
-			case fieldnum.FieldDescriptorProto_TypeName:
-				rawTypeName = v
-			case fieldnum.FieldDescriptorProto_Options:
-				fd.unmarshalOptions(v)
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	if rawTypeName != nil {
-		name := makeFullName(sb, rawTypeName)
-		switch fd.L1.Kind {
-		case pref.EnumKind:
-			fd.L1.Enum = PlaceholderEnum(name)
-		case pref.MessageKind, pref.GroupKind:
-			fd.L1.Message = PlaceholderMessage(name)
-		}
-	}
-	fd.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
-}
-
-func (fd *Field) unmarshalOptions(b []byte) {
-	const FieldOptions_EnforceUTF8 = 13
-
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FieldOptions_Packed:
-				fd.L1.HasPacked = true
-				fd.L1.IsPacked = protowire.DecodeBool(v)
-			case fieldnum.FieldOptions_Weak:
-				fd.L1.IsWeak = protowire.DecodeBool(v)
-			case FieldOptions_EnforceUTF8:
-				fd.L1.HasEnforceUTF8 = true
-				fd.L1.EnforceUTF8 = protowire.DecodeBool(v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}
-
-func (od *Oneof) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
-	od.L0.ParentFile = pf
-	od.L0.Parent = pd
-	od.L0.Index = i
-
-	var rawOptions []byte
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.OneofDescriptorProto_Name:
-				od.L0.FullName = appendFullName(sb, pd.FullName(), v)
-			case fieldnum.OneofDescriptorProto_Options:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	od.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Oneof, rawOptions)
-}
-
-func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) {
-	var rawTypeName []byte
-	var rawOptions []byte
-	xd.L2 = new(ExtensionL2)
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FieldDescriptorProto_Proto3Optional:
-				xd.L2.IsProto3Optional = protowire.DecodeBool(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FieldDescriptorProto_JsonName:
-				xd.L2.JSONName.Init(sb.MakeString(v))
-			case fieldnum.FieldDescriptorProto_DefaultValue:
-				xd.L2.Default.val = pref.ValueOfBytes(v) // temporarily store as bytes; later resolved in resolveExtensions
-			case fieldnum.FieldDescriptorProto_TypeName:
-				rawTypeName = v
-			case fieldnum.FieldDescriptorProto_Options:
-				xd.unmarshalOptions(v)
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	if rawTypeName != nil {
-		name := makeFullName(sb, rawTypeName)
-		switch xd.L1.Kind {
-		case pref.EnumKind:
-			xd.L2.Enum = PlaceholderEnum(name)
-		case pref.MessageKind, pref.GroupKind:
-			xd.L2.Message = PlaceholderMessage(name)
-		}
-	}
-	xd.L2.Options = xd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Field, rawOptions)
-}
-
-func (xd *Extension) unmarshalOptions(b []byte) {
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.FieldOptions_Packed:
-				xd.L2.IsPacked = protowire.DecodeBool(v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-}
-
-func (sd *Service) unmarshalFull(b []byte, sb *strs.Builder) {
-	var rawMethods [][]byte
-	var rawOptions []byte
-	sd.L2 = new(ServiceL2)
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.ServiceDescriptorProto_Method:
-				rawMethods = append(rawMethods, v)
-			case fieldnum.ServiceDescriptorProto_Options:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	if len(rawMethods) > 0 {
-		sd.L2.Methods.List = make([]Method, len(rawMethods))
-		for i, b := range rawMethods {
-			sd.L2.Methods.List[i].unmarshalFull(b, sb, sd.L0.ParentFile, sd, i)
-		}
-	}
-	sd.L2.Options = sd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Service, rawOptions)
-}
-
-func (md *Method) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd pref.Descriptor, i int) {
-	md.L0.ParentFile = pf
-	md.L0.Parent = pd
-	md.L0.Index = i
-
-	var rawOptions []byte
-	for len(b) > 0 {
-		num, typ, n := protowire.ConsumeTag(b)
-		b = b[n:]
-		switch typ {
-		case protowire.VarintType:
-			v, m := protowire.ConsumeVarint(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.MethodDescriptorProto_ClientStreaming:
-				md.L1.IsStreamingClient = protowire.DecodeBool(v)
-			case fieldnum.MethodDescriptorProto_ServerStreaming:
-				md.L1.IsStreamingServer = protowire.DecodeBool(v)
-			}
-		case protowire.BytesType:
-			v, m := protowire.ConsumeBytes(b)
-			b = b[m:]
-			switch num {
-			case fieldnum.MethodDescriptorProto_Name:
-				md.L0.FullName = appendFullName(sb, pd.FullName(), v)
-			case fieldnum.MethodDescriptorProto_InputType:
-				md.L1.Input = PlaceholderMessage(makeFullName(sb, v))
-			case fieldnum.MethodDescriptorProto_OutputType:
-				md.L1.Output = PlaceholderMessage(makeFullName(sb, v))
-			case fieldnum.MethodDescriptorProto_Options:
-				rawOptions = appendOptions(rawOptions, v)
-			}
-		default:
-			m := protowire.ConsumeFieldValue(num, typ, b)
-			b = b[m:]
-		}
-	}
-	md.L1.Options = pf.builder.optionsUnmarshaler(&descopts.Method, rawOptions)
-}
-
-// appendOptions appends src to dst, where the returned slice is never nil.
-// This is necessary to distinguish between empty and unpopulated options.
-func appendOptions(dst, src []byte) []byte {
-	if dst == nil {
-		dst = []byte{}
-	}
-	return append(dst, src...)
-}
-
-// optionsUnmarshaler constructs a lazy unmarshal function for an options message.
-//
-// The type of message to unmarshal to is passed as a pointer since the
-// vars in descopts may not yet be populated at the time this function is called.
-func (db *Builder) optionsUnmarshaler(p *pref.ProtoMessage, b []byte) func() pref.ProtoMessage {
-	if b == nil {
-		return nil
-	}
-	var opts pref.ProtoMessage
-	var once sync.Once
-	return func() pref.ProtoMessage {
-		once.Do(func() {
-			if *p == nil {
-				panic("Descriptor.Options called without importing the descriptor package")
-			}
-			opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(pref.ProtoMessage)
-			if err := (proto.UnmarshalOptions{
-				AllowPartial: true,
-				Resolver:     db.TypeResolver,
-			}).Unmarshal(b, opts); err != nil {
-				panic(err)
-			}
-		})
-		return opts
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_list.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_list.go
deleted file mode 100644
index 1b7089b..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_list.go
+++ /dev/null
@@ -1,286 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package filedesc
-
-import (
-	"fmt"
-	"math"
-	"sort"
-	"sync"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/descfmt"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type FileImports []pref.FileImport
-
-func (p *FileImports) Len() int                            { return len(*p) }
-func (p *FileImports) Get(i int) pref.FileImport           { return (*p)[i] }
-func (p *FileImports) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }
-func (p *FileImports) ProtoInternal(pragma.DoNotImplement) {}
-
-type Names struct {
-	List []pref.Name
-	once sync.Once
-	has  map[pref.Name]int // protected by once
-}
-
-func (p *Names) Len() int                            { return len(p.List) }
-func (p *Names) Get(i int) pref.Name                 { return p.List[i] }
-func (p *Names) Has(s pref.Name) bool                { return p.lazyInit().has[s] > 0 }
-func (p *Names) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }
-func (p *Names) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Names) lazyInit() *Names {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.has = make(map[pref.Name]int, len(p.List))
-			for _, s := range p.List {
-				p.has[s] = p.has[s] + 1
-			}
-		}
-	})
-	return p
-}
-
-// CheckValid reports any errors with the set of names with an error message
-// that completes the sentence: "ranges is invalid because it has ..."
-func (p *Names) CheckValid() error {
-	for s, n := range p.lazyInit().has {
-		switch {
-		case n > 1:
-			return errors.New("duplicate name: %q", s)
-		case false && !s.IsValid():
-			// NOTE: The C++ implementation does not validate the identifier.
-			// See https://github.com/protocolbuffers/protobuf/issues/6335.
-			return errors.New("invalid name: %q", s)
-		}
-	}
-	return nil
-}
-
-type EnumRanges struct {
-	List   [][2]pref.EnumNumber // start inclusive; end inclusive
-	once   sync.Once
-	sorted [][2]pref.EnumNumber // protected by once
-}
-
-func (p *EnumRanges) Len() int                     { return len(p.List) }
-func (p *EnumRanges) Get(i int) [2]pref.EnumNumber { return p.List[i] }
-func (p *EnumRanges) Has(n pref.EnumNumber) bool {
-	for ls := p.lazyInit().sorted; len(ls) > 0; {
-		i := len(ls) / 2
-		switch r := enumRange(ls[i]); {
-		case n < r.Start():
-			ls = ls[:i] // search lower
-		case n > r.End():
-			ls = ls[i+1:] // search upper
-		default:
-			return true
-		}
-	}
-	return false
-}
-func (p *EnumRanges) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }
-func (p *EnumRanges) ProtoInternal(pragma.DoNotImplement) {}
-func (p *EnumRanges) lazyInit() *EnumRanges {
-	p.once.Do(func() {
-		p.sorted = append(p.sorted, p.List...)
-		sort.Slice(p.sorted, func(i, j int) bool {
-			return p.sorted[i][0] < p.sorted[j][0]
-		})
-	})
-	return p
-}
-
-// CheckValid reports any errors with the set of names with an error message
-// that completes the sentence: "ranges is invalid because it has ..."
-func (p *EnumRanges) CheckValid() error {
-	var rp enumRange
-	for i, r := range p.lazyInit().sorted {
-		r := enumRange(r)
-		switch {
-		case !(r.Start() <= r.End()):
-			return errors.New("invalid range: %v", r)
-		case !(rp.End() < r.Start()) && i > 0:
-			return errors.New("overlapping ranges: %v with %v", rp, r)
-		}
-		rp = r
-	}
-	return nil
-}
-
-type enumRange [2]protoreflect.EnumNumber
-
-func (r enumRange) Start() protoreflect.EnumNumber { return r[0] } // inclusive
-func (r enumRange) End() protoreflect.EnumNumber   { return r[1] } // inclusive
-func (r enumRange) String() string {
-	if r.Start() == r.End() {
-		return fmt.Sprintf("%d", r.Start())
-	}
-	return fmt.Sprintf("%d to %d", r.Start(), r.End())
-}
-
-type FieldRanges struct {
-	List   [][2]pref.FieldNumber // start inclusive; end exclusive
-	once   sync.Once
-	sorted [][2]pref.FieldNumber // protected by once
-}
-
-func (p *FieldRanges) Len() int                      { return len(p.List) }
-func (p *FieldRanges) Get(i int) [2]pref.FieldNumber { return p.List[i] }
-func (p *FieldRanges) Has(n pref.FieldNumber) bool {
-	for ls := p.lazyInit().sorted; len(ls) > 0; {
-		i := len(ls) / 2
-		switch r := fieldRange(ls[i]); {
-		case n < r.Start():
-			ls = ls[:i] // search lower
-		case n > r.End():
-			ls = ls[i+1:] // search upper
-		default:
-			return true
-		}
-	}
-	return false
-}
-func (p *FieldRanges) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }
-func (p *FieldRanges) ProtoInternal(pragma.DoNotImplement) {}
-func (p *FieldRanges) lazyInit() *FieldRanges {
-	p.once.Do(func() {
-		p.sorted = append(p.sorted, p.List...)
-		sort.Slice(p.sorted, func(i, j int) bool {
-			return p.sorted[i][0] < p.sorted[j][0]
-		})
-	})
-	return p
-}
-
-// CheckValid reports any errors with the set of ranges with an error message
-// that completes the sentence: "ranges is invalid because it has ..."
-func (p *FieldRanges) CheckValid(isMessageSet bool) error {
-	var rp fieldRange
-	for i, r := range p.lazyInit().sorted {
-		r := fieldRange(r)
-		switch {
-		case !isValidFieldNumber(r.Start(), isMessageSet):
-			return errors.New("invalid field number: %d", r.Start())
-		case !isValidFieldNumber(r.End(), isMessageSet):
-			return errors.New("invalid field number: %d", r.End())
-		case !(r.Start() <= r.End()):
-			return errors.New("invalid range: %v", r)
-		case !(rp.End() < r.Start()) && i > 0:
-			return errors.New("overlapping ranges: %v with %v", rp, r)
-		}
-		rp = r
-	}
-	return nil
-}
-
-// isValidFieldNumber reports whether the field number is valid.
-// Unlike the FieldNumber.IsValid method, it allows ranges that cover the
-// reserved number range.
-func isValidFieldNumber(n protoreflect.FieldNumber, isMessageSet bool) bool {
-	if isMessageSet {
-		return protowire.MinValidNumber <= n && n <= math.MaxInt32
-	}
-	return protowire.MinValidNumber <= n && n <= protowire.MaxValidNumber
-}
-
-// CheckOverlap reports an error if p and q overlap.
-func (p *FieldRanges) CheckOverlap(q *FieldRanges) error {
-	rps := p.lazyInit().sorted
-	rqs := q.lazyInit().sorted
-	for pi, qi := 0, 0; pi < len(rps) && qi < len(rqs); {
-		rp := fieldRange(rps[pi])
-		rq := fieldRange(rqs[qi])
-		if !(rp.End() < rq.Start() || rq.End() < rp.Start()) {
-			return errors.New("overlapping ranges: %v with %v", rp, rq)
-		}
-		if rp.Start() < rq.Start() {
-			pi++
-		} else {
-			qi++
-		}
-	}
-	return nil
-}
-
-type fieldRange [2]protoreflect.FieldNumber
-
-func (r fieldRange) Start() protoreflect.FieldNumber { return r[0] }     // inclusive
-func (r fieldRange) End() protoreflect.FieldNumber   { return r[1] - 1 } // inclusive
-func (r fieldRange) String() string {
-	if r.Start() == r.End() {
-		return fmt.Sprintf("%d", r.Start())
-	}
-	return fmt.Sprintf("%d to %d", r.Start(), r.End())
-}
-
-type FieldNumbers struct {
-	List []pref.FieldNumber
-	once sync.Once
-	has  map[pref.FieldNumber]struct{} // protected by once
-}
-
-func (p *FieldNumbers) Len() int                   { return len(p.List) }
-func (p *FieldNumbers) Get(i int) pref.FieldNumber { return p.List[i] }
-func (p *FieldNumbers) Has(n pref.FieldNumber) bool {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.has = make(map[pref.FieldNumber]struct{}, len(p.List))
-			for _, n := range p.List {
-				p.has[n] = struct{}{}
-			}
-		}
-	})
-	_, ok := p.has[n]
-	return ok
-}
-func (p *FieldNumbers) Format(s fmt.State, r rune)          { descfmt.FormatList(s, r, p) }
-func (p *FieldNumbers) ProtoInternal(pragma.DoNotImplement) {}
-
-type OneofFields struct {
-	List   []pref.FieldDescriptor
-	once   sync.Once
-	byName map[pref.Name]pref.FieldDescriptor        // protected by once
-	byJSON map[string]pref.FieldDescriptor           // protected by once
-	byNum  map[pref.FieldNumber]pref.FieldDescriptor // protected by once
-}
-
-func (p *OneofFields) Len() int                                         { return len(p.List) }
-func (p *OneofFields) Get(i int) pref.FieldDescriptor                   { return p.List[i] }
-func (p *OneofFields) ByName(s pref.Name) pref.FieldDescriptor          { return p.lazyInit().byName[s] }
-func (p *OneofFields) ByJSONName(s string) pref.FieldDescriptor         { return p.lazyInit().byJSON[s] }
-func (p *OneofFields) ByNumber(n pref.FieldNumber) pref.FieldDescriptor { return p.lazyInit().byNum[n] }
-func (p *OneofFields) Format(s fmt.State, r rune)                       { descfmt.FormatList(s, r, p) }
-func (p *OneofFields) ProtoInternal(pragma.DoNotImplement)              {}
-
-func (p *OneofFields) lazyInit() *OneofFields {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.byName = make(map[pref.Name]pref.FieldDescriptor, len(p.List))
-			p.byJSON = make(map[string]pref.FieldDescriptor, len(p.List))
-			p.byNum = make(map[pref.FieldNumber]pref.FieldDescriptor, len(p.List))
-			for _, f := range p.List {
-				// Field names and numbers are guaranteed to be unique.
-				p.byName[f.Name()] = f
-				p.byJSON[f.JSONName()] = f
-				p.byNum[f.Number()] = f
-			}
-		}
-	})
-	return p
-}
-
-type SourceLocations struct {
-	List []pref.SourceLocation
-}
-
-func (p *SourceLocations) Len() int                            { return len(p.List) }
-func (p *SourceLocations) Get(i int) pref.SourceLocation       { return p.List[i] }
-func (p *SourceLocations) ProtoInternal(pragma.DoNotImplement) {}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go b/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go
deleted file mode 100644
index 6a8825e..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go
+++ /dev/null
@@ -1,345 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package filedesc
-
-import (
-	"fmt"
-	"sync"
-
-	"google.golang.org/protobuf/internal/descfmt"
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type Enums struct {
-	List   []Enum
-	once   sync.Once
-	byName map[protoreflect.Name]*Enum // protected by once
-}
-
-func (p *Enums) Len() int {
-	return len(p.List)
-}
-func (p *Enums) Get(i int) protoreflect.EnumDescriptor {
-	return &p.List[i]
-}
-func (p *Enums) ByName(s protoreflect.Name) protoreflect.EnumDescriptor {
-	if d := p.lazyInit().byName[s]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *Enums) Format(s fmt.State, r rune) {
-	descfmt.FormatList(s, r, p)
-}
-func (p *Enums) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Enums) lazyInit() *Enums {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.byName = make(map[protoreflect.Name]*Enum, len(p.List))
-			for i := range p.List {
-				d := &p.List[i]
-				if _, ok := p.byName[d.Name()]; !ok {
-					p.byName[d.Name()] = d
-				}
-			}
-		}
-	})
-	return p
-}
-
-type EnumValues struct {
-	List   []EnumValue
-	once   sync.Once
-	byName map[protoreflect.Name]*EnumValue       // protected by once
-	byNum  map[protoreflect.EnumNumber]*EnumValue // protected by once
-}
-
-func (p *EnumValues) Len() int {
-	return len(p.List)
-}
-func (p *EnumValues) Get(i int) protoreflect.EnumValueDescriptor {
-	return &p.List[i]
-}
-func (p *EnumValues) ByName(s protoreflect.Name) protoreflect.EnumValueDescriptor {
-	if d := p.lazyInit().byName[s]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *EnumValues) ByNumber(n protoreflect.EnumNumber) protoreflect.EnumValueDescriptor {
-	if d := p.lazyInit().byNum[n]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *EnumValues) Format(s fmt.State, r rune) {
-	descfmt.FormatList(s, r, p)
-}
-func (p *EnumValues) ProtoInternal(pragma.DoNotImplement) {}
-func (p *EnumValues) lazyInit() *EnumValues {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.byName = make(map[protoreflect.Name]*EnumValue, len(p.List))
-			p.byNum = make(map[protoreflect.EnumNumber]*EnumValue, len(p.List))
-			for i := range p.List {
-				d := &p.List[i]
-				if _, ok := p.byName[d.Name()]; !ok {
-					p.byName[d.Name()] = d
-				}
-				if _, ok := p.byNum[d.Number()]; !ok {
-					p.byNum[d.Number()] = d
-				}
-			}
-		}
-	})
-	return p
-}
-
-type Messages struct {
-	List   []Message
-	once   sync.Once
-	byName map[protoreflect.Name]*Message // protected by once
-}
-
-func (p *Messages) Len() int {
-	return len(p.List)
-}
-func (p *Messages) Get(i int) protoreflect.MessageDescriptor {
-	return &p.List[i]
-}
-func (p *Messages) ByName(s protoreflect.Name) protoreflect.MessageDescriptor {
-	if d := p.lazyInit().byName[s]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *Messages) Format(s fmt.State, r rune) {
-	descfmt.FormatList(s, r, p)
-}
-func (p *Messages) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Messages) lazyInit() *Messages {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.byName = make(map[protoreflect.Name]*Message, len(p.List))
-			for i := range p.List {
-				d := &p.List[i]
-				if _, ok := p.byName[d.Name()]; !ok {
-					p.byName[d.Name()] = d
-				}
-			}
-		}
-	})
-	return p
-}
-
-type Fields struct {
-	List   []Field
-	once   sync.Once
-	byName map[protoreflect.Name]*Field        // protected by once
-	byJSON map[string]*Field                   // protected by once
-	byNum  map[protoreflect.FieldNumber]*Field // protected by once
-}
-
-func (p *Fields) Len() int {
-	return len(p.List)
-}
-func (p *Fields) Get(i int) protoreflect.FieldDescriptor {
-	return &p.List[i]
-}
-func (p *Fields) ByName(s protoreflect.Name) protoreflect.FieldDescriptor {
-	if d := p.lazyInit().byName[s]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *Fields) ByJSONName(s string) protoreflect.FieldDescriptor {
-	if d := p.lazyInit().byJSON[s]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *Fields) ByNumber(n protoreflect.FieldNumber) protoreflect.FieldDescriptor {
-	if d := p.lazyInit().byNum[n]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *Fields) Format(s fmt.State, r rune) {
-	descfmt.FormatList(s, r, p)
-}
-func (p *Fields) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Fields) lazyInit() *Fields {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.byName = make(map[protoreflect.Name]*Field, len(p.List))
-			p.byJSON = make(map[string]*Field, len(p.List))
-			p.byNum = make(map[protoreflect.FieldNumber]*Field, len(p.List))
-			for i := range p.List {
-				d := &p.List[i]
-				if _, ok := p.byName[d.Name()]; !ok {
-					p.byName[d.Name()] = d
-				}
-				if _, ok := p.byJSON[d.JSONName()]; !ok {
-					p.byJSON[d.JSONName()] = d
-				}
-				if _, ok := p.byNum[d.Number()]; !ok {
-					p.byNum[d.Number()] = d
-				}
-			}
-		}
-	})
-	return p
-}
-
-type Oneofs struct {
-	List   []Oneof
-	once   sync.Once
-	byName map[protoreflect.Name]*Oneof // protected by once
-}
-
-func (p *Oneofs) Len() int {
-	return len(p.List)
-}
-func (p *Oneofs) Get(i int) protoreflect.OneofDescriptor {
-	return &p.List[i]
-}
-func (p *Oneofs) ByName(s protoreflect.Name) protoreflect.OneofDescriptor {
-	if d := p.lazyInit().byName[s]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *Oneofs) Format(s fmt.State, r rune) {
-	descfmt.FormatList(s, r, p)
-}
-func (p *Oneofs) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Oneofs) lazyInit() *Oneofs {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.byName = make(map[protoreflect.Name]*Oneof, len(p.List))
-			for i := range p.List {
-				d := &p.List[i]
-				if _, ok := p.byName[d.Name()]; !ok {
-					p.byName[d.Name()] = d
-				}
-			}
-		}
-	})
-	return p
-}
-
-type Extensions struct {
-	List   []Extension
-	once   sync.Once
-	byName map[protoreflect.Name]*Extension // protected by once
-}
-
-func (p *Extensions) Len() int {
-	return len(p.List)
-}
-func (p *Extensions) Get(i int) protoreflect.ExtensionDescriptor {
-	return &p.List[i]
-}
-func (p *Extensions) ByName(s protoreflect.Name) protoreflect.ExtensionDescriptor {
-	if d := p.lazyInit().byName[s]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *Extensions) Format(s fmt.State, r rune) {
-	descfmt.FormatList(s, r, p)
-}
-func (p *Extensions) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Extensions) lazyInit() *Extensions {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.byName = make(map[protoreflect.Name]*Extension, len(p.List))
-			for i := range p.List {
-				d := &p.List[i]
-				if _, ok := p.byName[d.Name()]; !ok {
-					p.byName[d.Name()] = d
-				}
-			}
-		}
-	})
-	return p
-}
-
-type Services struct {
-	List   []Service
-	once   sync.Once
-	byName map[protoreflect.Name]*Service // protected by once
-}
-
-func (p *Services) Len() int {
-	return len(p.List)
-}
-func (p *Services) Get(i int) protoreflect.ServiceDescriptor {
-	return &p.List[i]
-}
-func (p *Services) ByName(s protoreflect.Name) protoreflect.ServiceDescriptor {
-	if d := p.lazyInit().byName[s]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *Services) Format(s fmt.State, r rune) {
-	descfmt.FormatList(s, r, p)
-}
-func (p *Services) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Services) lazyInit() *Services {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.byName = make(map[protoreflect.Name]*Service, len(p.List))
-			for i := range p.List {
-				d := &p.List[i]
-				if _, ok := p.byName[d.Name()]; !ok {
-					p.byName[d.Name()] = d
-				}
-			}
-		}
-	})
-	return p
-}
-
-type Methods struct {
-	List   []Method
-	once   sync.Once
-	byName map[protoreflect.Name]*Method // protected by once
-}
-
-func (p *Methods) Len() int {
-	return len(p.List)
-}
-func (p *Methods) Get(i int) protoreflect.MethodDescriptor {
-	return &p.List[i]
-}
-func (p *Methods) ByName(s protoreflect.Name) protoreflect.MethodDescriptor {
-	if d := p.lazyInit().byName[s]; d != nil {
-		return d
-	}
-	return nil
-}
-func (p *Methods) Format(s fmt.State, r rune) {
-	descfmt.FormatList(s, r, p)
-}
-func (p *Methods) ProtoInternal(pragma.DoNotImplement) {}
-func (p *Methods) lazyInit() *Methods {
-	p.once.Do(func() {
-		if len(p.List) > 0 {
-			p.byName = make(map[protoreflect.Name]*Method, len(p.List))
-			for i := range p.List {
-				d := &p.List[i]
-				if _, ok := p.byName[d.Name()]; !ok {
-					p.byName[d.Name()] = d
-				}
-			}
-		}
-	})
-	return p
-}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go b/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go
deleted file mode 100644
index dbf2c60..0000000
--- a/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package filedesc
-
-import (
-	"google.golang.org/protobuf/internal/descopts"
-	"google.golang.org/protobuf/internal/pragma"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-var (
-	emptyNames           = new(Names)
-	emptyEnumRanges      = new(EnumRanges)
-	emptyFieldRanges     = new(FieldRanges)
-	emptyFieldNumbers    = new(FieldNumbers)
-	emptySourceLocations = new(SourceLocations)
-
-	emptyFiles      = new(FileImports)
-	emptyMessages   = new(Messages)
-	emptyFields     = new(Fields)
-	emptyOneofs     = new(Oneofs)
-	emptyEnums      = new(Enums)
-	emptyEnumValues = new(EnumValues)
-	emptyExtensions = new(Extensions)
-	emptyServices   = new(Services)
-)
-
-// PlaceholderFile is a placeholder, representing only the file path.
-type PlaceholderFile string
-
-func (f PlaceholderFile) ParentFile() pref.FileDescriptor       { return f }
-func (f PlaceholderFile) Parent() pref.Descriptor               { return nil }
-func (f PlaceholderFile) Index() int                            { return 0 }
-func (f PlaceholderFile) Syntax() pref.Syntax                   { return 0 }
-func (f PlaceholderFile) Name() pref.Name                       { return "" }
-func (f PlaceholderFile) FullName() pref.FullName               { return "" }
-func (f PlaceholderFile) IsPlaceholder() bool                   { return true }
-func (f PlaceholderFile) Options() pref.ProtoMessage            { return descopts.File }
-func (f PlaceholderFile) Path() string                          { return string(f) }
-func (f PlaceholderFile) Package() pref.FullName                { return "" }
-func (f PlaceholderFile) Imports() pref.FileImports             { return emptyFiles }
-func (f PlaceholderFile) Messages() pref.MessageDescriptors     { return emptyMessages }
-func (f PlaceholderFile) Enums() pref.EnumDescriptors           { return emptyEnums }
-func (f PlaceholderFile) Extensions() pref.ExtensionDescriptors { return emptyExtensions }
-func (f PlaceholderFile) Services() pref.ServiceDescriptors     { return emptyServices }
-func (f PlaceholderFile) SourceLocations() pref.SourceLocations { return emptySourceLocations }
-func (f PlaceholderFile) ProtoType(pref.FileDescriptor)         { return }
-func (f PlaceholderFile) ProtoInternal(pragma.DoNotImplement)   { return }
-
-// PlaceholderEnum is a placeholder, representing only the full name.
-type PlaceholderEnum pref.FullName
-
-func (e PlaceholderEnum) ParentFile() pref.FileDescriptor     { return nil }
-func (e PlaceholderEnum) Parent() pref.Descriptor             { return nil }
-func (e PlaceholderEnum) Index() int                          { return 0 }
-func (e PlaceholderEnum) Syntax() pref.Syntax                 { return 0 }
-func (e PlaceholderEnum) Name() pref.Name                     { return pref.FullName(e).Name() }
-func (e PlaceholderEnum) FullName() pref.FullName             { return pref.FullName(e) }
-func (e PlaceholderEnum) IsPlaceholder() bool                 { return true }
-func (e PlaceholderEnum) Options() pref.ProtoMessage          { return descopts.Enum }
-func (e PlaceholderEnum) Values() pref.EnumValueDescriptors   { return emptyEnumValues }
-func (e PlaceholderEnum) ReservedNames() pref.Names           { return emptyNames }
-func (e PlaceholderEnum) ReservedRanges() pref.EnumRanges     { return emptyEnumRanges }
-func (e PlaceholderEnum) ProtoType(pref.EnumDescriptor)       { return }
-func (e PlaceholderEnum) ProtoInternal(pragma.DoNotImplement) { return }
-
-// PlaceholderEnumValue is a placeholder, representing only the full name.
-type PlaceholderEnumValue pref.FullName
-
-func (e PlaceholderEnumValue) ParentFile() pref.FileDescriptor     { return nil }
-func (e PlaceholderEnumValue) Parent() pref.Descriptor             { return nil }
-func (e PlaceholderEnumValue) Index() int                          { return 0 }
-func (e PlaceholderEnumValue) Syntax() pref.Syntax                 { return 0 }
-func (e PlaceholderEnumValue) Name() pref.Name                     { return pref.FullName(e).Name() }
-func (e PlaceholderEnumValue) FullName() pref.FullName             { return pref.FullName(e) }
-func (e PlaceholderEnumValue) IsPlaceholder() bool                 { return true }
-func (e PlaceholderEnumValue) Options() pref.ProtoMessage          { return descopts.EnumValue }
-func (e PlaceholderEnumValue) Number() pref.EnumNumber             { return 0 }
-func (e PlaceholderEnumValue) ProtoType(pref.EnumValueDescriptor)  { return }
-func (e PlaceholderEnumValue) ProtoInternal(pragma.DoNotImplement) { return }
-
-// PlaceholderMessage is a placeholder, representing only the full name.
-type PlaceholderMessage pref.FullName
-
-func (m PlaceholderMessage) ParentFile() pref.FileDescriptor             { return nil }
-func (m PlaceholderMessage) Parent() pref.Descriptor                     { return nil }
-func (m PlaceholderMessage) Index() int                                  { return 0 }
-func (m PlaceholderMessage) Syntax() pref.Syntax                         { return 0 }
-func (m PlaceholderMessage) Name() pref.Name                             { return pref.FullName(m).Name() }
-func (m PlaceholderMessage) FullName() pref.FullName                     { return pref.FullName(m) }
-func (m PlaceholderMessage) IsPlaceholder() bool                         { return true }
-func (m PlaceholderMessage) Options() pref.ProtoMessage                  { return descopts.Message }
-func (m PlaceholderMessage) IsMapEntry() bool                            { return false }
-func (m PlaceholderMessage) Fields() pref.FieldDescriptors               { return emptyFields }
-func (m PlaceholderMessage) Oneofs() pref.OneofDescriptors               { return emptyOneofs }
-func (m PlaceholderMessage) ReservedNames() pref.Names                   { return emptyNames }
-func (m PlaceholderMessage) ReservedRanges() pref.FieldRanges            { return emptyFieldRanges }
-func (m PlaceholderMessage) RequiredNumbers() pref.FieldNumbers          { return emptyFieldNumbers }
-func (m PlaceholderMessage) ExtensionRanges() pref.FieldRanges           { return emptyFieldRanges }
-func (m PlaceholderMessage) ExtensionRangeOptions(int) pref.ProtoMessage { panic("index out of range") }
-func (m PlaceholderMessage) Messages() pref.MessageDescriptors           { return emptyMessages }
-func (m PlaceholderMessage) Enums() pref.EnumDescriptors                 { return emptyEnums }
-func (m PlaceholderMessage) Extensions() pref.ExtensionDescriptors       { return emptyExtensions }
-func (m PlaceholderMessage) ProtoType(pref.MessageDescriptor)            { return }
-func (m PlaceholderMessage) ProtoInternal(pragma.DoNotImplement)         { return }
diff --git a/vendor/google.golang.org/protobuf/internal/filetype/build.go b/vendor/google.golang.org/protobuf/internal/filetype/build.go
deleted file mode 100644
index 0a0dd35..0000000
--- a/vendor/google.golang.org/protobuf/internal/filetype/build.go
+++ /dev/null
@@ -1,297 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package filetype provides functionality for wrapping descriptors
-// with Go type information.
-package filetype
-
-import (
-	"reflect"
-
-	"google.golang.org/protobuf/internal/descopts"
-	fdesc "google.golang.org/protobuf/internal/filedesc"
-	pimpl "google.golang.org/protobuf/internal/impl"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// Builder constructs type descriptors from a raw file descriptor
-// and associated Go types for each enum and message declaration.
-//
-//
-// Flattened Ordering
-//
-// The protobuf type system represents declarations as a tree. Certain nodes in
-// the tree require us to either associate it with a concrete Go type or to
-// resolve a dependency, which is information that must be provided separately
-// since it cannot be derived from the file descriptor alone.
-//
-// However, representing a tree as Go literals is difficult to simply do in a
-// space and time efficient way. Thus, we store them as a flattened list of
-// objects where the serialization order from the tree-based form is important.
-//
-// The "flattened ordering" is defined as a tree traversal of all enum, message,
-// extension, and service declarations using the following algorithm:
-//
-//	def VisitFileDecls(fd):
-//		for e in fd.Enums:      yield e
-//		for m in fd.Messages:   yield m
-//		for x in fd.Extensions: yield x
-//		for s in fd.Services:   yield s
-//		for m in fd.Messages:   yield from VisitMessageDecls(m)
-//
-//	def VisitMessageDecls(md):
-//		for e in md.Enums:      yield e
-//		for m in md.Messages:   yield m
-//		for x in md.Extensions: yield x
-//		for m in md.Messages:   yield from VisitMessageDecls(m)
-//
-// The traversal starts at the root file descriptor and yields each direct
-// declaration within each node before traversing into sub-declarations
-// that children themselves may have.
-type Builder struct {
-	// File is the underlying file descriptor builder.
-	File fdesc.Builder
-
-	// GoTypes is a unique set of the Go types for all declarations and
-	// dependencies. Each type is represented as a zero value of the Go type.
-	//
-	// Declarations are Go types generated for enums and messages directly
-	// declared (not publicly imported) in the proto source file.
-	// Messages for map entries are accounted for, but represented by nil.
-	// Enum declarations in "flattened ordering" come first, followed by
-	// message declarations in "flattened ordering".
-	//
-	// Dependencies are Go types for enums or messages referenced by
-	// message fields (excluding weak fields), for parent extended messages of
-	// extension fields, for enums or messages referenced by extension fields,
-	// and for input and output messages referenced by service methods.
-	// Dependencies must come after declarations, but the ordering of
-	// dependencies themselves is unspecified.
-	GoTypes []interface{}
-
-	// DependencyIndexes is an ordered list of indexes into GoTypes for the
-	// dependencies of messages, extensions, or services.
-	//
-	// There are 5 sub-lists in "flattened ordering" concatenated back-to-back:
-	//	0. Message field dependencies: list of the enum or message type
-	//	referred to by every message field.
-	//	1. Extension field targets: list of the extended parent message of
-	//	every extension.
-	//	2. Extension field dependencies: list of the enum or message type
-	//	referred to by every extension field.
-	//	3. Service method inputs: list of the input message type
-	//	referred to by every service method.
-	//	4. Service method outputs: list of the output message type
-	//	referred to by every service method.
-	//
-	// The offset into DependencyIndexes for the start of each sub-list
-	// is appended to the end in reverse order.
-	DependencyIndexes []int32
-
-	// EnumInfos is a list of enum infos in "flattened ordering".
-	EnumInfos []pimpl.EnumInfo
-
-	// MessageInfos is a list of message infos in "flattened ordering".
-	// If provided, the GoType and PBType for each element is populated.
-	//
-	// Requirement: len(MessageInfos) == len(Build.Messages)
-	MessageInfos []pimpl.MessageInfo
-
-	// ExtensionInfos is a list of extension infos in "flattened ordering".
-	// Each element is initialized and registered with the protoregistry package.
-	//
-	// Requirement: len(LegacyExtensions) == len(Build.Extensions)
-	ExtensionInfos []pimpl.ExtensionInfo
-
-	// TypeRegistry is the registry to register each type descriptor.
-	// If nil, it uses protoregistry.GlobalTypes.
-	TypeRegistry interface {
-		RegisterMessage(pref.MessageType) error
-		RegisterEnum(pref.EnumType) error
-		RegisterExtension(pref.ExtensionType) error
-	}
-}
-
-// Out is the output of the builder.
-type Out struct {
-	File pref.FileDescriptor
-}
-
-func (tb Builder) Build() (out Out) {
-	// Replace the resolver with one that resolves dependencies by index,
-	// which is faster and more reliable than relying on the global registry.
-	if tb.File.FileRegistry == nil {
-		tb.File.FileRegistry = preg.GlobalFiles
-	}
-	tb.File.FileRegistry = &resolverByIndex{
-		goTypes:      tb.GoTypes,
-		depIdxs:      tb.DependencyIndexes,
-		fileRegistry: tb.File.FileRegistry,
-	}
-
-	// Initialize registry if unpopulated.
-	if tb.TypeRegistry == nil {
-		tb.TypeRegistry = preg.GlobalTypes
-	}
-
-	fbOut := tb.File.Build()
-	out.File = fbOut.File
-
-	// Process enums.
-	enumGoTypes := tb.GoTypes[:len(fbOut.Enums)]
-	if len(tb.EnumInfos) != len(fbOut.Enums) {
-		panic("mismatching enum lengths")
-	}
-	if len(fbOut.Enums) > 0 {
-		for i := range fbOut.Enums {
-			tb.EnumInfos[i] = pimpl.EnumInfo{
-				GoReflectType: reflect.TypeOf(enumGoTypes[i]),
-				Desc:          &fbOut.Enums[i],
-			}
-			// Register enum types.
-			if err := tb.TypeRegistry.RegisterEnum(&tb.EnumInfos[i]); err != nil {
-				panic(err)
-			}
-		}
-	}
-
-	// Process messages.
-	messageGoTypes := tb.GoTypes[len(fbOut.Enums):][:len(fbOut.Messages)]
-	if len(tb.MessageInfos) != len(fbOut.Messages) {
-		panic("mismatching message lengths")
-	}
-	if len(fbOut.Messages) > 0 {
-		for i := range fbOut.Messages {
-			if messageGoTypes[i] == nil {
-				continue // skip map entry
-			}
-
-			tb.MessageInfos[i].GoReflectType = reflect.TypeOf(messageGoTypes[i])
-			tb.MessageInfos[i].Desc = &fbOut.Messages[i]
-
-			// Register message types.
-			if err := tb.TypeRegistry.RegisterMessage(&tb.MessageInfos[i]); err != nil {
-				panic(err)
-			}
-		}
-
-		// As a special-case for descriptor.proto,
-		// locally register concrete message type for the options.
-		if out.File.Path() == "google/protobuf/descriptor.proto" && out.File.Package() == "google.protobuf" {
-			for i := range fbOut.Messages {
-				switch fbOut.Messages[i].Name() {
-				case "FileOptions":
-					descopts.File = messageGoTypes[i].(pref.ProtoMessage)
-				case "EnumOptions":
-					descopts.Enum = messageGoTypes[i].(pref.ProtoMessage)
-				case "EnumValueOptions":
-					descopts.EnumValue = messageGoTypes[i].(pref.ProtoMessage)
-				case "MessageOptions":
-					descopts.Message = messageGoTypes[i].(pref.ProtoMessage)
-				case "FieldOptions":
-					descopts.Field = messageGoTypes[i].(pref.ProtoMessage)
-				case "OneofOptions":
-					descopts.Oneof = messageGoTypes[i].(pref.ProtoMessage)
-				case "ExtensionRangeOptions":
-					descopts.ExtensionRange = messageGoTypes[i].(pref.ProtoMessage)
-				case "ServiceOptions":
-					descopts.Service = messageGoTypes[i].(pref.ProtoMessage)
-				case "MethodOptions":
-					descopts.Method = messageGoTypes[i].(pref.ProtoMessage)
-				}
-			}
-		}
-	}
-
-	// Process extensions.
-	if len(tb.ExtensionInfos) != len(fbOut.Extensions) {
-		panic("mismatching extension lengths")
-	}
-	var depIdx int32
-	for i := range fbOut.Extensions {
-		// For enum and message kinds, determine the referent Go type so
-		// that we can construct their constructors.
-		const listExtDeps = 2
-		var goType reflect.Type
-		switch fbOut.Extensions[i].L1.Kind {
-		case pref.EnumKind:
-			j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
-			goType = reflect.TypeOf(tb.GoTypes[j])
-			depIdx++
-		case pref.MessageKind, pref.GroupKind:
-			j := depIdxs.Get(tb.DependencyIndexes, listExtDeps, depIdx)
-			goType = reflect.TypeOf(tb.GoTypes[j])
-			depIdx++
-		default:
-			goType = goTypeForPBKind[fbOut.Extensions[i].L1.Kind]
-		}
-		if fbOut.Extensions[i].IsList() {
-			goType = reflect.SliceOf(goType)
-		}
-
-		pimpl.InitExtensionInfo(&tb.ExtensionInfos[i], &fbOut.Extensions[i], goType)
-
-		// Register extension types.
-		if err := tb.TypeRegistry.RegisterExtension(&tb.ExtensionInfos[i]); err != nil {
-			panic(err)
-		}
-	}
-
-	return out
-}
-
-var goTypeForPBKind = map[pref.Kind]reflect.Type{
-	pref.BoolKind:     reflect.TypeOf(bool(false)),
-	pref.Int32Kind:    reflect.TypeOf(int32(0)),
-	pref.Sint32Kind:   reflect.TypeOf(int32(0)),
-	pref.Sfixed32Kind: reflect.TypeOf(int32(0)),
-	pref.Int64Kind:    reflect.TypeOf(int64(0)),
-	pref.Sint64Kind:   reflect.TypeOf(int64(0)),
-	pref.Sfixed64Kind: reflect.TypeOf(int64(0)),
-	pref.Uint32Kind:   reflect.TypeOf(uint32(0)),
-	pref.Fixed32Kind:  reflect.TypeOf(uint32(0)),
-	pref.Uint64Kind:   reflect.TypeOf(uint64(0)),
-	pref.Fixed64Kind:  reflect.TypeOf(uint64(0)),
-	pref.FloatKind:    reflect.TypeOf(float32(0)),
-	pref.DoubleKind:   reflect.TypeOf(float64(0)),
-	pref.StringKind:   reflect.TypeOf(string("")),
-	pref.BytesKind:    reflect.TypeOf([]byte(nil)),
-}
-
-type depIdxs []int32
-
-// Get retrieves the jth element of the ith sub-list.
-func (x depIdxs) Get(i, j int32) int32 {
-	return x[x[int32(len(x))-i-1]+j]
-}
-
-type (
-	resolverByIndex struct {
-		goTypes []interface{}
-		depIdxs depIdxs
-		fileRegistry
-	}
-	fileRegistry interface {
-		FindFileByPath(string) (pref.FileDescriptor, error)
-		FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
-		RegisterFile(pref.FileDescriptor) error
-	}
-)
-
-func (r *resolverByIndex) FindEnumByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.EnumDescriptor {
-	if depIdx := int(r.depIdxs.Get(i, j)); int(depIdx) < len(es)+len(ms) {
-		return &es[depIdx]
-	} else {
-		return pimpl.Export{}.EnumDescriptorOf(r.goTypes[depIdx])
-	}
-}
-
-func (r *resolverByIndex) FindMessageByIndex(i, j int32, es []fdesc.Enum, ms []fdesc.Message) pref.MessageDescriptor {
-	if depIdx := int(r.depIdxs.Get(i, j)); depIdx < len(es)+len(ms) {
-		return &ms[depIdx-len(es)]
-	} else {
-		return pimpl.Export{}.MessageDescriptorOf(r.goTypes[depIdx])
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/flags/flags.go b/vendor/google.golang.org/protobuf/internal/flags/flags.go
deleted file mode 100644
index 58372dd..0000000
--- a/vendor/google.golang.org/protobuf/internal/flags/flags.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package flags provides a set of flags controlled by build tags.
-package flags
-
-// ProtoLegacy specifies whether to enable support for legacy functionality
-// such as MessageSets, weak fields, and various other obscure behavior
-// that is necessary to maintain backwards compatibility with proto1 or
-// the pre-release variants of proto2 and proto3.
-//
-// This is disabled by default unless built with the "protolegacy" tag.
-//
-// WARNING: The compatibility agreement covers nothing provided by this flag.
-// As such, functionality may suddenly be removed or changed at our discretion.
-const ProtoLegacy = protoLegacy
-
-// LazyUnmarshalExtensions specifies whether to lazily unmarshal extensions.
-//
-// Lazy extension unmarshaling validates the contents of message-valued
-// extension fields at unmarshal time, but defers creating the message
-// structure until the extension is first accessed.
-const LazyUnmarshalExtensions = ProtoLegacy
diff --git a/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go b/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go
deleted file mode 100644
index a72995f..0000000
--- a/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !protolegacy
-
-package flags
-
-const protoLegacy = false
diff --git a/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go b/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go
deleted file mode 100644
index 772e2f0..0000000
--- a/vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build protolegacy
-
-package flags
-
-const protoLegacy = true
diff --git a/vendor/google.golang.org/protobuf/internal/genname/name.go b/vendor/google.golang.org/protobuf/internal/genname/name.go
deleted file mode 100644
index f45509f..0000000
--- a/vendor/google.golang.org/protobuf/internal/genname/name.go
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package genname contains constants for generated names.
-package genname
-
-const (
-	State = "state"
-
-	SizeCache  = "sizeCache"
-	SizeCacheA = "XXX_sizecache"
-
-	WeakFields  = "weakFields"
-	WeakFieldsA = "XXX_weak"
-
-	UnknownFields  = "unknownFields"
-	UnknownFieldsA = "XXX_unrecognized"
-
-	ExtensionFields  = "extensionFields"
-	ExtensionFieldsA = "XXX_InternalExtensions"
-	ExtensionFieldsB = "XXX_extensions"
-
-	WeakFieldPrefix = "XXX_weak_"
-)
diff --git a/vendor/google.golang.org/protobuf/internal/impl/api_export.go b/vendor/google.golang.org/protobuf/internal/impl/api_export.go
deleted file mode 100644
index 4d22c96..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/api_export.go
+++ /dev/null
@@ -1,170 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-
-	"google.golang.org/protobuf/encoding/prototext"
-	"google.golang.org/protobuf/proto"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// Export is a zero-length named type that exists only to export a set of
-// functions that we do not want to appear in godoc.
-type Export struct{}
-
-// enum is any enum type generated by protoc-gen-go
-// and must be a named int32 type.
-type enum = interface{}
-
-// EnumOf returns the protoreflect.Enum interface over e.
-// It returns nil if e is nil.
-func (Export) EnumOf(e enum) pref.Enum {
-	switch e := e.(type) {
-	case nil:
-		return nil
-	case pref.Enum:
-		return e
-	default:
-		return legacyWrapEnum(reflect.ValueOf(e))
-	}
-}
-
-// EnumDescriptorOf returns the protoreflect.EnumDescriptor for e.
-// It returns nil if e is nil.
-func (Export) EnumDescriptorOf(e enum) pref.EnumDescriptor {
-	switch e := e.(type) {
-	case nil:
-		return nil
-	case pref.Enum:
-		return e.Descriptor()
-	default:
-		return LegacyLoadEnumDesc(reflect.TypeOf(e))
-	}
-}
-
-// EnumTypeOf returns the protoreflect.EnumType for e.
-// It returns nil if e is nil.
-func (Export) EnumTypeOf(e enum) pref.EnumType {
-	switch e := e.(type) {
-	case nil:
-		return nil
-	case pref.Enum:
-		return e.Type()
-	default:
-		return legacyLoadEnumType(reflect.TypeOf(e))
-	}
-}
-
-// EnumStringOf returns the enum value as a string, either as the name if
-// the number is resolvable, or the number formatted as a string.
-func (Export) EnumStringOf(ed pref.EnumDescriptor, n pref.EnumNumber) string {
-	ev := ed.Values().ByNumber(n)
-	if ev != nil {
-		return string(ev.Name())
-	}
-	return strconv.Itoa(int(n))
-}
-
-// message is any message type generated by protoc-gen-go
-// and must be a pointer to a named struct type.
-type message = interface{}
-
-// legacyMessageWrapper wraps a v2 message as a v1 message.
-type legacyMessageWrapper struct{ m pref.ProtoMessage }
-
-func (m legacyMessageWrapper) Reset()         { proto.Reset(m.m) }
-func (m legacyMessageWrapper) String() string { return Export{}.MessageStringOf(m.m) }
-func (m legacyMessageWrapper) ProtoMessage()  {}
-
-// ProtoMessageV1Of converts either a v1 or v2 message to a v1 message.
-// It returns nil if m is nil.
-func (Export) ProtoMessageV1Of(m message) piface.MessageV1 {
-	switch mv := m.(type) {
-	case nil:
-		return nil
-	case piface.MessageV1:
-		return mv
-	case unwrapper:
-		return Export{}.ProtoMessageV1Of(mv.protoUnwrap())
-	case pref.ProtoMessage:
-		return legacyMessageWrapper{mv}
-	default:
-		panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
-	}
-}
-
-func (Export) protoMessageV2Of(m message) pref.ProtoMessage {
-	switch mv := m.(type) {
-	case nil:
-		return nil
-	case pref.ProtoMessage:
-		return mv
-	case legacyMessageWrapper:
-		return mv.m
-	case piface.MessageV1:
-		return nil
-	default:
-		panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
-	}
-}
-
-// ProtoMessageV2Of converts either a v1 or v2 message to a v2 message.
-// It returns nil if m is nil.
-func (Export) ProtoMessageV2Of(m message) pref.ProtoMessage {
-	if m == nil {
-		return nil
-	}
-	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
-		return mv
-	}
-	return legacyWrapMessage(reflect.ValueOf(m)).Interface()
-}
-
-// MessageOf returns the protoreflect.Message interface over m.
-// It returns nil if m is nil.
-func (Export) MessageOf(m message) pref.Message {
-	if m == nil {
-		return nil
-	}
-	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
-		return mv.ProtoReflect()
-	}
-	return legacyWrapMessage(reflect.ValueOf(m))
-}
-
-// MessageDescriptorOf returns the protoreflect.MessageDescriptor for m.
-// It returns nil if m is nil.
-func (Export) MessageDescriptorOf(m message) pref.MessageDescriptor {
-	if m == nil {
-		return nil
-	}
-	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
-		return mv.ProtoReflect().Descriptor()
-	}
-	return LegacyLoadMessageDesc(reflect.TypeOf(m))
-}
-
-// MessageTypeOf returns the protoreflect.MessageType for m.
-// It returns nil if m is nil.
-func (Export) MessageTypeOf(m message) pref.MessageType {
-	if m == nil {
-		return nil
-	}
-	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
-		return mv.ProtoReflect().Type()
-	}
-	return legacyLoadMessageInfo(reflect.TypeOf(m), "")
-}
-
-// MessageStringOf returns the message value as a string,
-// which is the message serialized in the protobuf text format.
-func (Export) MessageStringOf(m pref.ProtoMessage) string {
-	return prototext.MarshalOptions{Multiline: false}.Format(m)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/checkinit.go b/vendor/google.golang.org/protobuf/internal/impl/checkinit.go
deleted file mode 100644
index b82341e..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/checkinit.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"sync"
-
-	"google.golang.org/protobuf/internal/errors"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-func (mi *MessageInfo) checkInitialized(in piface.CheckInitializedInput) (piface.CheckInitializedOutput, error) {
-	var p pointer
-	if ms, ok := in.Message.(*messageState); ok {
-		p = ms.pointer()
-	} else {
-		p = in.Message.(*messageReflectWrapper).pointer()
-	}
-	return piface.CheckInitializedOutput{}, mi.checkInitializedPointer(p)
-}
-
-func (mi *MessageInfo) checkInitializedPointer(p pointer) error {
-	mi.init()
-	if !mi.needsInitCheck {
-		return nil
-	}
-	if p.IsNil() {
-		for _, f := range mi.orderedCoderFields {
-			if f.isRequired {
-				return errors.RequiredNotSet(string(mi.Desc.Fields().ByNumber(f.num).FullName()))
-			}
-		}
-		return nil
-	}
-	if mi.extensionOffset.IsValid() {
-		e := p.Apply(mi.extensionOffset).Extensions()
-		if err := mi.isInitExtensions(e); err != nil {
-			return err
-		}
-	}
-	for _, f := range mi.orderedCoderFields {
-		if !f.isRequired && f.funcs.isInit == nil {
-			continue
-		}
-		fptr := p.Apply(f.offset)
-		if f.isPointer && fptr.Elem().IsNil() {
-			if f.isRequired {
-				return errors.RequiredNotSet(string(mi.Desc.Fields().ByNumber(f.num).FullName()))
-			}
-			continue
-		}
-		if f.funcs.isInit == nil {
-			continue
-		}
-		if err := f.funcs.isInit(fptr, f); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (mi *MessageInfo) isInitExtensions(ext *map[int32]ExtensionField) error {
-	if ext == nil {
-		return nil
-	}
-	for _, x := range *ext {
-		ei := getExtensionFieldInfo(x.Type())
-		if ei.funcs.isInit == nil {
-			continue
-		}
-		v := x.Value()
-		if !v.IsValid() {
-			continue
-		}
-		if err := ei.funcs.isInit(v); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-var (
-	needsInitCheckMu  sync.Mutex
-	needsInitCheckMap sync.Map
-)
-
-// needsInitCheck reports whether a message needs to be checked for partial initialization.
-//
-// It returns true if the message transitively includes any required or extension fields.
-func needsInitCheck(md pref.MessageDescriptor) bool {
-	if v, ok := needsInitCheckMap.Load(md); ok {
-		if has, ok := v.(bool); ok {
-			return has
-		}
-	}
-	needsInitCheckMu.Lock()
-	defer needsInitCheckMu.Unlock()
-	return needsInitCheckLocked(md)
-}
-
-func needsInitCheckLocked(md pref.MessageDescriptor) (has bool) {
-	if v, ok := needsInitCheckMap.Load(md); ok {
-		// If has is true, we've previously determined that this message
-		// needs init checks.
-		//
-		// If has is false, we've previously determined that it can never
-		// be uninitialized.
-		//
-		// If has is not a bool, we've just encountered a cycle in the
-		// message graph. In this case, it is safe to return false: If
-		// the message does have required fields, we'll detect them later
-		// in the graph traversal.
-		has, ok := v.(bool)
-		return ok && has
-	}
-	needsInitCheckMap.Store(md, struct{}{}) // avoid cycles while descending into this message
-	defer func() {
-		needsInitCheckMap.Store(md, has)
-	}()
-	if md.RequiredNumbers().Len() > 0 {
-		return true
-	}
-	if md.ExtensionRanges().Len() > 0 {
-		return true
-	}
-	for i := 0; i < md.Fields().Len(); i++ {
-		fd := md.Fields().Get(i)
-		// Map keys are never messages, so just consider the map value.
-		if fd.IsMap() {
-			fd = fd.MapValue()
-		}
-		fmd := fd.Message()
-		if fmd != nil && needsInitCheckLocked(fmd) {
-			return true
-		}
-	}
-	return false
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go b/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go
deleted file mode 100644
index 08d3517..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"sync"
-	"sync/atomic"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/errors"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type extensionFieldInfo struct {
-	wiretag             uint64
-	tagsize             int
-	unmarshalNeedsValue bool
-	funcs               valueCoderFuncs
-	validation          validationInfo
-}
-
-var legacyExtensionFieldInfoCache sync.Map // map[protoreflect.ExtensionType]*extensionFieldInfo
-
-func getExtensionFieldInfo(xt pref.ExtensionType) *extensionFieldInfo {
-	if xi, ok := xt.(*ExtensionInfo); ok {
-		xi.lazyInit()
-		return xi.info
-	}
-	return legacyLoadExtensionFieldInfo(xt)
-}
-
-// legacyLoadExtensionFieldInfo dynamically loads a *ExtensionInfo for xt.
-func legacyLoadExtensionFieldInfo(xt pref.ExtensionType) *extensionFieldInfo {
-	if xi, ok := legacyExtensionFieldInfoCache.Load(xt); ok {
-		return xi.(*extensionFieldInfo)
-	}
-	e := makeExtensionFieldInfo(xt.TypeDescriptor())
-	if e, ok := legacyMessageTypeCache.LoadOrStore(xt, e); ok {
-		return e.(*extensionFieldInfo)
-	}
-	return e
-}
-
-func makeExtensionFieldInfo(xd pref.ExtensionDescriptor) *extensionFieldInfo {
-	var wiretag uint64
-	if !xd.IsPacked() {
-		wiretag = protowire.EncodeTag(xd.Number(), wireTypes[xd.Kind()])
-	} else {
-		wiretag = protowire.EncodeTag(xd.Number(), protowire.BytesType)
-	}
-	e := &extensionFieldInfo{
-		wiretag: wiretag,
-		tagsize: protowire.SizeVarint(wiretag),
-		funcs:   encoderFuncsForValue(xd),
-	}
-	// Does the unmarshal function need a value passed to it?
-	// This is true for composite types, where we pass in a message, list, or map to fill in,
-	// and for enums, where we pass in a prototype value to specify the concrete enum type.
-	switch xd.Kind() {
-	case pref.MessageKind, pref.GroupKind, pref.EnumKind:
-		e.unmarshalNeedsValue = true
-	default:
-		if xd.Cardinality() == pref.Repeated {
-			e.unmarshalNeedsValue = true
-		}
-	}
-	return e
-}
-
-type lazyExtensionValue struct {
-	atomicOnce uint32 // atomically set if value is valid
-	mu         sync.Mutex
-	xi         *extensionFieldInfo
-	value      pref.Value
-	b          []byte
-	fn         func() pref.Value
-}
-
-type ExtensionField struct {
-	typ pref.ExtensionType
-
-	// value is either the value of GetValue,
-	// or a *lazyExtensionValue that then returns the value of GetValue.
-	value pref.Value
-	lazy  *lazyExtensionValue
-}
-
-func (f *ExtensionField) appendLazyBytes(xt pref.ExtensionType, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, b []byte) {
-	if f.lazy == nil {
-		f.lazy = &lazyExtensionValue{xi: xi}
-	}
-	f.typ = xt
-	f.lazy.xi = xi
-	f.lazy.b = protowire.AppendTag(f.lazy.b, num, wtyp)
-	f.lazy.b = append(f.lazy.b, b...)
-}
-
-func (f *ExtensionField) canLazy(xt pref.ExtensionType) bool {
-	if f.typ == nil {
-		return true
-	}
-	if f.typ == xt && f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
-		return true
-	}
-	return false
-}
-
-func (f *ExtensionField) lazyInit() {
-	f.lazy.mu.Lock()
-	defer f.lazy.mu.Unlock()
-	if atomic.LoadUint32(&f.lazy.atomicOnce) == 1 {
-		return
-	}
-	if f.lazy.xi != nil {
-		b := f.lazy.b
-		val := f.typ.New()
-		for len(b) > 0 {
-			var tag uint64
-			if b[0] < 0x80 {
-				tag = uint64(b[0])
-				b = b[1:]
-			} else if len(b) >= 2 && b[1] < 128 {
-				tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				b = b[2:]
-			} else {
-				var n int
-				tag, n = protowire.ConsumeVarint(b)
-				if n < 0 {
-					panic(errors.New("bad tag in lazy extension decoding"))
-				}
-				b = b[n:]
-			}
-			num := protowire.Number(tag >> 3)
-			wtyp := protowire.Type(tag & 7)
-			var out unmarshalOutput
-			var err error
-			val, out, err = f.lazy.xi.funcs.unmarshal(b, val, num, wtyp, lazyUnmarshalOptions)
-			if err != nil {
-				panic(errors.New("decode failure in lazy extension decoding: %v", err))
-			}
-			b = b[out.n:]
-		}
-		f.lazy.value = val
-	} else {
-		f.lazy.value = f.lazy.fn()
-	}
-	f.lazy.xi = nil
-	f.lazy.fn = nil
-	f.lazy.b = nil
-	atomic.StoreUint32(&f.lazy.atomicOnce, 1)
-}
-
-// Set sets the type and value of the extension field.
-// This must not be called concurrently.
-func (f *ExtensionField) Set(t pref.ExtensionType, v pref.Value) {
-	f.typ = t
-	f.value = v
-	f.lazy = nil
-}
-
-// SetLazy sets the type and a value that is to be lazily evaluated upon first use.
-// This must not be called concurrently.
-func (f *ExtensionField) SetLazy(t pref.ExtensionType, fn func() pref.Value) {
-	f.typ = t
-	f.lazy = &lazyExtensionValue{fn: fn}
-}
-
-// Value returns the value of the extension field.
-// This may be called concurrently.
-func (f *ExtensionField) Value() pref.Value {
-	if f.lazy != nil {
-		if atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
-			f.lazyInit()
-		}
-		return f.lazy.value
-	}
-	return f.value
-}
-
-// Type returns the type of the extension field.
-// This may be called concurrently.
-func (f ExtensionField) Type() pref.ExtensionType {
-	return f.typ
-}
-
-// IsSet returns whether the extension field is set.
-// This may be called concurrently.
-func (f ExtensionField) IsSet() bool {
-	return f.typ != nil
-}
-
-// IsLazy reports whether a field is lazily encoded.
-// It is exported for testing.
-func IsLazy(m pref.Message, fd pref.FieldDescriptor) bool {
-	var mi *MessageInfo
-	var p pointer
-	switch m := m.(type) {
-	case *messageState:
-		mi = m.messageInfo()
-		p = m.pointer()
-	case *messageReflectWrapper:
-		mi = m.messageInfo()
-		p = m.pointer()
-	default:
-		return false
-	}
-	xd, ok := fd.(pref.ExtensionTypeDescriptor)
-	if !ok {
-		return false
-	}
-	xt := xd.Type()
-	ext := mi.extensionMap(p)
-	if ext == nil {
-		return false
-	}
-	f, ok := (*ext)[int32(fd.Number())]
-	if !ok {
-		return false
-	}
-	return f.typ == xt && f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_field.go b/vendor/google.golang.org/protobuf/internal/impl/codec_field.go
deleted file mode 100644
index c00744d..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_field.go
+++ /dev/null
@@ -1,828 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-	"sync"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/proto"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-type errInvalidUTF8 struct{}
-
-func (errInvalidUTF8) Error() string     { return "string field contains invalid UTF-8" }
-func (errInvalidUTF8) InvalidUTF8() bool { return true }
-
-// initOneofFieldCoders initializes the fast-path functions for the fields in a oneof.
-//
-// For size, marshal, and isInit operations, functions are set only on the first field
-// in the oneof. The functions are called when the oneof is non-nil, and will dispatch
-// to the appropriate field-specific function as necessary.
-//
-// The unmarshal function is set on each field individually as usual.
-func (mi *MessageInfo) initOneofFieldCoders(od pref.OneofDescriptor, si structInfo) {
-	fs := si.oneofsByName[od.Name()]
-	ft := fs.Type
-	oneofFields := make(map[reflect.Type]*coderFieldInfo)
-	needIsInit := false
-	fields := od.Fields()
-	for i, lim := 0, fields.Len(); i < lim; i++ {
-		fd := od.Fields().Get(i)
-		num := fd.Number()
-		// Make a copy of the original coderFieldInfo for use in unmarshaling.
-		//
-		// oneofFields[oneofType].funcs.marshal is the field-specific marshal function.
-		//
-		// mi.coderFields[num].marshal is set on only the first field in the oneof,
-		// and dispatches to the field-specific marshaler in oneofFields.
-		cf := *mi.coderFields[num]
-		ot := si.oneofWrappersByNumber[num]
-		cf.ft = ot.Field(0).Type
-		cf.mi, cf.funcs = fieldCoder(fd, cf.ft)
-		oneofFields[ot] = &cf
-		if cf.funcs.isInit != nil {
-			needIsInit = true
-		}
-		mi.coderFields[num].funcs.unmarshal = func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
-			var vw reflect.Value         // pointer to wrapper type
-			vi := p.AsValueOf(ft).Elem() // oneof field value of interface kind
-			if !vi.IsNil() && !vi.Elem().IsNil() && vi.Elem().Elem().Type() == ot {
-				vw = vi.Elem()
-			} else {
-				vw = reflect.New(ot)
-			}
-			out, err := cf.funcs.unmarshal(b, pointerOfValue(vw).Apply(zeroOffset), wtyp, &cf, opts)
-			if err != nil {
-				return out, err
-			}
-			vi.Set(vw)
-			return out, nil
-		}
-	}
-	getInfo := func(p pointer) (pointer, *coderFieldInfo) {
-		v := p.AsValueOf(ft).Elem()
-		if v.IsNil() {
-			return pointer{}, nil
-		}
-		v = v.Elem() // interface -> *struct
-		if v.IsNil() {
-			return pointer{}, nil
-		}
-		return pointerOfValue(v).Apply(zeroOffset), oneofFields[v.Elem().Type()]
-	}
-	first := mi.coderFields[od.Fields().Get(0).Number()]
-	first.funcs.size = func(p pointer, _ *coderFieldInfo, opts marshalOptions) int {
-		p, info := getInfo(p)
-		if info == nil || info.funcs.size == nil {
-			return 0
-		}
-		return info.funcs.size(p, info, opts)
-	}
-	first.funcs.marshal = func(b []byte, p pointer, _ *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-		p, info := getInfo(p)
-		if info == nil || info.funcs.marshal == nil {
-			return b, nil
-		}
-		return info.funcs.marshal(b, p, info, opts)
-	}
-	first.funcs.merge = func(dst, src pointer, _ *coderFieldInfo, opts mergeOptions) {
-		srcp, srcinfo := getInfo(src)
-		if srcinfo == nil || srcinfo.funcs.merge == nil {
-			return
-		}
-		dstp, dstinfo := getInfo(dst)
-		if dstinfo != srcinfo {
-			dst.AsValueOf(ft).Elem().Set(reflect.New(src.AsValueOf(ft).Elem().Elem().Elem().Type()))
-			dstp = pointerOfValue(dst.AsValueOf(ft).Elem().Elem()).Apply(zeroOffset)
-		}
-		srcinfo.funcs.merge(dstp, srcp, srcinfo, opts)
-	}
-	if needIsInit {
-		first.funcs.isInit = func(p pointer, _ *coderFieldInfo) error {
-			p, info := getInfo(p)
-			if info == nil || info.funcs.isInit == nil {
-				return nil
-			}
-			return info.funcs.isInit(p, info)
-		}
-	}
-}
-
-func makeWeakMessageFieldCoder(fd pref.FieldDescriptor) pointerCoderFuncs {
-	var once sync.Once
-	var messageType pref.MessageType
-	lazyInit := func() {
-		once.Do(func() {
-			messageName := fd.Message().FullName()
-			messageType, _ = preg.GlobalTypes.FindMessageByName(messageName)
-		})
-	}
-
-	return pointerCoderFuncs{
-		size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-			m, ok := p.WeakFields().get(f.num)
-			if !ok {
-				return 0
-			}
-			lazyInit()
-			if messageType == nil {
-				panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
-			}
-			return sizeMessage(m, f.tagsize, opts)
-		},
-		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-			m, ok := p.WeakFields().get(f.num)
-			if !ok {
-				return b, nil
-			}
-			lazyInit()
-			if messageType == nil {
-				panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
-			}
-			return appendMessage(b, m, f.wiretag, opts)
-		},
-		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
-			fs := p.WeakFields()
-			m, ok := fs.get(f.num)
-			if !ok {
-				lazyInit()
-				if messageType == nil {
-					return unmarshalOutput{}, errUnknown
-				}
-				m = messageType.New().Interface()
-				fs.set(f.num, m)
-			}
-			return consumeMessage(b, m, wtyp, opts)
-		},
-		isInit: func(p pointer, f *coderFieldInfo) error {
-			m, ok := p.WeakFields().get(f.num)
-			if !ok {
-				return nil
-			}
-			return proto.CheckInitialized(m)
-		},
-		merge: func(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
-			sm, ok := src.WeakFields().get(f.num)
-			if !ok {
-				return
-			}
-			dm, ok := dst.WeakFields().get(f.num)
-			if !ok {
-				lazyInit()
-				if messageType == nil {
-					panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
-				}
-				dm = messageType.New().Interface()
-				dst.WeakFields().set(f.num, dm)
-			}
-			opts.Merge(dm, sm)
-		},
-	}
-}
-
-func makeMessageFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
-	if mi := getMessageInfo(ft); mi != nil {
-		funcs := pointerCoderFuncs{
-			size:      sizeMessageInfo,
-			marshal:   appendMessageInfo,
-			unmarshal: consumeMessageInfo,
-			merge:     mergeMessage,
-		}
-		if needsInitCheck(mi.Desc) {
-			funcs.isInit = isInitMessageInfo
-		}
-		return funcs
-	} else {
-		return pointerCoderFuncs{
-			size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-				m := asMessage(p.AsValueOf(ft).Elem())
-				return sizeMessage(m, f.tagsize, opts)
-			},
-			marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-				m := asMessage(p.AsValueOf(ft).Elem())
-				return appendMessage(b, m, f.wiretag, opts)
-			},
-			unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
-				mp := p.AsValueOf(ft).Elem()
-				if mp.IsNil() {
-					mp.Set(reflect.New(ft.Elem()))
-				}
-				return consumeMessage(b, asMessage(mp), wtyp, opts)
-			},
-			isInit: func(p pointer, f *coderFieldInfo) error {
-				m := asMessage(p.AsValueOf(ft).Elem())
-				return proto.CheckInitialized(m)
-			},
-			merge: mergeMessage,
-		}
-	}
-}
-
-func sizeMessageInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-	return protowire.SizeBytes(f.mi.sizePointer(p.Elem(), opts)) + f.tagsize
-}
-
-func appendMessageInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(f.mi.sizePointer(p.Elem(), opts)))
-	return f.mi.marshalAppendPointer(b, p.Elem(), opts)
-}
-
-func consumeMessageInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	if p.Elem().IsNil() {
-		p.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
-	}
-	o, err := f.mi.unmarshalPointer(v, p.Elem(), 0, opts)
-	if err != nil {
-		return out, err
-	}
-	out.n = n
-	out.initialized = o.initialized
-	return out, nil
-}
-
-func isInitMessageInfo(p pointer, f *coderFieldInfo) error {
-	return f.mi.checkInitializedPointer(p.Elem())
-}
-
-func sizeMessage(m proto.Message, tagsize int, _ marshalOptions) int {
-	return protowire.SizeBytes(proto.Size(m)) + tagsize
-}
-
-func appendMessage(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendVarint(b, uint64(proto.Size(m)))
-	return opts.Options().MarshalAppend(b, m)
-}
-
-func consumeMessage(b []byte, m proto.Message, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
-		Buf:     v,
-		Message: m.ProtoReflect(),
-	})
-	if err != nil {
-		return out, err
-	}
-	out.n = n
-	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
-	return out, nil
-}
-
-func sizeMessageValue(v pref.Value, tagsize int, opts marshalOptions) int {
-	m := v.Message().Interface()
-	return sizeMessage(m, tagsize, opts)
-}
-
-func appendMessageValue(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
-	m := v.Message().Interface()
-	return appendMessage(b, m, wiretag, opts)
-}
-
-func consumeMessageValue(b []byte, v pref.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) {
-	m := v.Message().Interface()
-	out, err := consumeMessage(b, m, wtyp, opts)
-	return v, out, err
-}
-
-func isInitMessageValue(v pref.Value) error {
-	m := v.Message().Interface()
-	return proto.CheckInitialized(m)
-}
-
-var coderMessageValue = valueCoderFuncs{
-	size:      sizeMessageValue,
-	marshal:   appendMessageValue,
-	unmarshal: consumeMessageValue,
-	isInit:    isInitMessageValue,
-	merge:     mergeMessageValue,
-}
-
-func sizeGroupValue(v pref.Value, tagsize int, opts marshalOptions) int {
-	m := v.Message().Interface()
-	return sizeGroup(m, tagsize, opts)
-}
-
-func appendGroupValue(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
-	m := v.Message().Interface()
-	return appendGroup(b, m, wiretag, opts)
-}
-
-func consumeGroupValue(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) {
-	m := v.Message().Interface()
-	out, err := consumeGroup(b, m, num, wtyp, opts)
-	return v, out, err
-}
-
-var coderGroupValue = valueCoderFuncs{
-	size:      sizeGroupValue,
-	marshal:   appendGroupValue,
-	unmarshal: consumeGroupValue,
-	isInit:    isInitMessageValue,
-	merge:     mergeMessageValue,
-}
-
-func makeGroupFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
-	num := fd.Number()
-	if mi := getMessageInfo(ft); mi != nil {
-		funcs := pointerCoderFuncs{
-			size:      sizeGroupType,
-			marshal:   appendGroupType,
-			unmarshal: consumeGroupType,
-			merge:     mergeMessage,
-		}
-		if needsInitCheck(mi.Desc) {
-			funcs.isInit = isInitMessageInfo
-		}
-		return funcs
-	} else {
-		return pointerCoderFuncs{
-			size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-				m := asMessage(p.AsValueOf(ft).Elem())
-				return sizeGroup(m, f.tagsize, opts)
-			},
-			marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-				m := asMessage(p.AsValueOf(ft).Elem())
-				return appendGroup(b, m, f.wiretag, opts)
-			},
-			unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
-				mp := p.AsValueOf(ft).Elem()
-				if mp.IsNil() {
-					mp.Set(reflect.New(ft.Elem()))
-				}
-				return consumeGroup(b, asMessage(mp), num, wtyp, opts)
-			},
-			isInit: func(p pointer, f *coderFieldInfo) error {
-				m := asMessage(p.AsValueOf(ft).Elem())
-				return proto.CheckInitialized(m)
-			},
-			merge: mergeMessage,
-		}
-	}
-}
-
-func sizeGroupType(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-	return 2*f.tagsize + f.mi.sizePointer(p.Elem(), opts)
-}
-
-func appendGroupType(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, f.wiretag) // start group
-	b, err := f.mi.marshalAppendPointer(b, p.Elem(), opts)
-	b = protowire.AppendVarint(b, f.wiretag+1) // end group
-	return b, err
-}
-
-func consumeGroupType(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.StartGroupType {
-		return out, errUnknown
-	}
-	if p.Elem().IsNil() {
-		p.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
-	}
-	return f.mi.unmarshalPointer(b, p.Elem(), f.num, opts)
-}
-
-func sizeGroup(m proto.Message, tagsize int, _ marshalOptions) int {
-	return 2*tagsize + proto.Size(m)
-}
-
-func appendGroup(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag) // start group
-	b, err := opts.Options().MarshalAppend(b, m)
-	b = protowire.AppendVarint(b, wiretag+1) // end group
-	return b, err
-}
-
-func consumeGroup(b []byte, m proto.Message, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.StartGroupType {
-		return out, errUnknown
-	}
-	b, n := protowire.ConsumeGroup(num, b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
-		Buf:     b,
-		Message: m.ProtoReflect(),
-	})
-	if err != nil {
-		return out, err
-	}
-	out.n = n
-	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
-	return out, nil
-}
-
-func makeMessageSliceFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
-	if mi := getMessageInfo(ft); mi != nil {
-		funcs := pointerCoderFuncs{
-			size:      sizeMessageSliceInfo,
-			marshal:   appendMessageSliceInfo,
-			unmarshal: consumeMessageSliceInfo,
-			merge:     mergeMessageSlice,
-		}
-		if needsInitCheck(mi.Desc) {
-			funcs.isInit = isInitMessageSliceInfo
-		}
-		return funcs
-	}
-	return pointerCoderFuncs{
-		size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-			return sizeMessageSlice(p, ft, f.tagsize, opts)
-		},
-		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-			return appendMessageSlice(b, p, f.wiretag, ft, opts)
-		},
-		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
-			return consumeMessageSlice(b, p, ft, wtyp, opts)
-		},
-		isInit: func(p pointer, f *coderFieldInfo) error {
-			return isInitMessageSlice(p, ft)
-		},
-		merge: mergeMessageSlice,
-	}
-}
-
-func sizeMessageSliceInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-	s := p.PointerSlice()
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeBytes(f.mi.sizePointer(v, opts)) + f.tagsize
-	}
-	return n
-}
-
-func appendMessageSliceInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	s := p.PointerSlice()
-	var err error
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		siz := f.mi.sizePointer(v, opts)
-		b = protowire.AppendVarint(b, uint64(siz))
-		b, err = f.mi.marshalAppendPointer(b, v, opts)
-		if err != nil {
-			return b, err
-		}
-	}
-	return b, nil
-}
-
-func consumeMessageSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
-	mp := pointerOfIface(m)
-	o, err := f.mi.unmarshalPointer(v, mp, 0, opts)
-	if err != nil {
-		return out, err
-	}
-	p.AppendPointerSlice(mp)
-	out.n = n
-	out.initialized = o.initialized
-	return out, nil
-}
-
-func isInitMessageSliceInfo(p pointer, f *coderFieldInfo) error {
-	s := p.PointerSlice()
-	for _, v := range s {
-		if err := f.mi.checkInitializedPointer(v); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func sizeMessageSlice(p pointer, goType reflect.Type, tagsize int, _ marshalOptions) int {
-	s := p.PointerSlice()
-	n := 0
-	for _, v := range s {
-		m := asMessage(v.AsValueOf(goType.Elem()))
-		n += protowire.SizeBytes(proto.Size(m)) + tagsize
-	}
-	return n
-}
-
-func appendMessageSlice(b []byte, p pointer, wiretag uint64, goType reflect.Type, opts marshalOptions) ([]byte, error) {
-	s := p.PointerSlice()
-	var err error
-	for _, v := range s {
-		m := asMessage(v.AsValueOf(goType.Elem()))
-		b = protowire.AppendVarint(b, wiretag)
-		siz := proto.Size(m)
-		b = protowire.AppendVarint(b, uint64(siz))
-		b, err = opts.Options().MarshalAppend(b, m)
-		if err != nil {
-			return b, err
-		}
-	}
-	return b, nil
-}
-
-func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	mp := reflect.New(goType.Elem())
-	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
-		Buf:     v,
-		Message: asMessage(mp).ProtoReflect(),
-	})
-	if err != nil {
-		return out, err
-	}
-	p.AppendPointerSlice(pointerOfValue(mp))
-	out.n = n
-	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
-	return out, nil
-}
-
-func isInitMessageSlice(p pointer, goType reflect.Type) error {
-	s := p.PointerSlice()
-	for _, v := range s {
-		m := asMessage(v.AsValueOf(goType.Elem()))
-		if err := proto.CheckInitialized(m); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Slices of messages
-
-func sizeMessageSliceValue(listv pref.Value, tagsize int, opts marshalOptions) int {
-	list := listv.List()
-	n := 0
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		m := list.Get(i).Message().Interface()
-		n += protowire.SizeBytes(proto.Size(m)) + tagsize
-	}
-	return n
-}
-
-func appendMessageSliceValue(b []byte, listv pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
-	list := listv.List()
-	mopts := opts.Options()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		m := list.Get(i).Message().Interface()
-		b = protowire.AppendVarint(b, wiretag)
-		siz := proto.Size(m)
-		b = protowire.AppendVarint(b, uint64(siz))
-		var err error
-		b, err = mopts.MarshalAppend(b, m)
-		if err != nil {
-			return b, err
-		}
-	}
-	return b, nil
-}
-
-func consumeMessageSliceValue(b []byte, listv pref.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp != protowire.BytesType {
-		return pref.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return pref.Value{}, out, protowire.ParseError(n)
-	}
-	m := list.NewElement()
-	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
-		Buf:     v,
-		Message: m.Message(),
-	})
-	if err != nil {
-		return pref.Value{}, out, err
-	}
-	list.Append(m)
-	out.n = n
-	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
-	return listv, out, nil
-}
-
-func isInitMessageSliceValue(listv pref.Value) error {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		m := list.Get(i).Message().Interface()
-		if err := proto.CheckInitialized(m); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-var coderMessageSliceValue = valueCoderFuncs{
-	size:      sizeMessageSliceValue,
-	marshal:   appendMessageSliceValue,
-	unmarshal: consumeMessageSliceValue,
-	isInit:    isInitMessageSliceValue,
-	merge:     mergeMessageListValue,
-}
-
-func sizeGroupSliceValue(listv pref.Value, tagsize int, opts marshalOptions) int {
-	list := listv.List()
-	n := 0
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		m := list.Get(i).Message().Interface()
-		n += 2*tagsize + proto.Size(m)
-	}
-	return n
-}
-
-func appendGroupSliceValue(b []byte, listv pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
-	list := listv.List()
-	mopts := opts.Options()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		m := list.Get(i).Message().Interface()
-		b = protowire.AppendVarint(b, wiretag) // start group
-		var err error
-		b, err = mopts.MarshalAppend(b, m)
-		if err != nil {
-			return b, err
-		}
-		b = protowire.AppendVarint(b, wiretag+1) // end group
-	}
-	return b, nil
-}
-
-func consumeGroupSliceValue(b []byte, listv pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ pref.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp != protowire.StartGroupType {
-		return pref.Value{}, out, errUnknown
-	}
-	b, n := protowire.ConsumeGroup(num, b)
-	if n < 0 {
-		return pref.Value{}, out, protowire.ParseError(n)
-	}
-	m := list.NewElement()
-	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
-		Buf:     b,
-		Message: m.Message(),
-	})
-	if err != nil {
-		return pref.Value{}, out, err
-	}
-	list.Append(m)
-	out.n = n
-	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
-	return listv, out, nil
-}
-
-var coderGroupSliceValue = valueCoderFuncs{
-	size:      sizeGroupSliceValue,
-	marshal:   appendGroupSliceValue,
-	unmarshal: consumeGroupSliceValue,
-	isInit:    isInitMessageSliceValue,
-	merge:     mergeMessageListValue,
-}
-
-func makeGroupSliceFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
-	num := fd.Number()
-	if mi := getMessageInfo(ft); mi != nil {
-		funcs := pointerCoderFuncs{
-			size:      sizeGroupSliceInfo,
-			marshal:   appendGroupSliceInfo,
-			unmarshal: consumeGroupSliceInfo,
-			merge:     mergeMessageSlice,
-		}
-		if needsInitCheck(mi.Desc) {
-			funcs.isInit = isInitMessageSliceInfo
-		}
-		return funcs
-	}
-	return pointerCoderFuncs{
-		size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-			return sizeGroupSlice(p, ft, f.tagsize, opts)
-		},
-		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-			return appendGroupSlice(b, p, f.wiretag, ft, opts)
-		},
-		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
-			return consumeGroupSlice(b, p, num, wtyp, ft, opts)
-		},
-		isInit: func(p pointer, f *coderFieldInfo) error {
-			return isInitMessageSlice(p, ft)
-		},
-		merge: mergeMessageSlice,
-	}
-}
-
-func sizeGroupSlice(p pointer, messageType reflect.Type, tagsize int, _ marshalOptions) int {
-	s := p.PointerSlice()
-	n := 0
-	for _, v := range s {
-		m := asMessage(v.AsValueOf(messageType.Elem()))
-		n += 2*tagsize + proto.Size(m)
-	}
-	return n
-}
-
-func appendGroupSlice(b []byte, p pointer, wiretag uint64, messageType reflect.Type, opts marshalOptions) ([]byte, error) {
-	s := p.PointerSlice()
-	var err error
-	for _, v := range s {
-		m := asMessage(v.AsValueOf(messageType.Elem()))
-		b = protowire.AppendVarint(b, wiretag) // start group
-		b, err = opts.Options().MarshalAppend(b, m)
-		if err != nil {
-			return b, err
-		}
-		b = protowire.AppendVarint(b, wiretag+1) // end group
-	}
-	return b, nil
-}
-
-func consumeGroupSlice(b []byte, p pointer, num protowire.Number, wtyp protowire.Type, goType reflect.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.StartGroupType {
-		return out, errUnknown
-	}
-	b, n := protowire.ConsumeGroup(num, b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	mp := reflect.New(goType.Elem())
-	o, err := opts.Options().UnmarshalState(piface.UnmarshalInput{
-		Buf:     b,
-		Message: asMessage(mp).ProtoReflect(),
-	})
-	if err != nil {
-		return out, err
-	}
-	p.AppendPointerSlice(pointerOfValue(mp))
-	out.n = n
-	out.initialized = o.Flags&piface.UnmarshalInitialized != 0
-	return out, nil
-}
-
-func sizeGroupSliceInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-	s := p.PointerSlice()
-	n := 0
-	for _, v := range s {
-		n += 2*f.tagsize + f.mi.sizePointer(v, opts)
-	}
-	return n
-}
-
-func appendGroupSliceInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	s := p.PointerSlice()
-	var err error
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag) // start group
-		b, err = f.mi.marshalAppendPointer(b, v, opts)
-		if err != nil {
-			return b, err
-		}
-		b = protowire.AppendVarint(b, f.wiretag+1) // end group
-	}
-	return b, nil
-}
-
-func consumeGroupSliceInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
-	if wtyp != protowire.StartGroupType {
-		return unmarshalOutput{}, errUnknown
-	}
-	m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
-	mp := pointerOfIface(m)
-	out, err := f.mi.unmarshalPointer(b, mp, f.num, opts)
-	if err != nil {
-		return out, err
-	}
-	p.AppendPointerSlice(mp)
-	return out, nil
-}
-
-func asMessage(v reflect.Value) pref.ProtoMessage {
-	if m, ok := v.Interface().(pref.ProtoMessage); ok {
-		return m
-	}
-	return legacyWrapMessage(v).Interface()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_gen.go b/vendor/google.golang.org/protobuf/internal/impl/codec_gen.go
deleted file mode 100644
index ff198d0..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_gen.go
+++ /dev/null
@@ -1,5637 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package impl
-
-import (
-	"math"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// sizeBool returns the size of wire encoding a bool pointer as a Bool.
-func sizeBool(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Bool()
-	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
-}
-
-// appendBool wire encodes a bool pointer as a Bool.
-func appendBool(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Bool()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
-	return b, nil
-}
-
-// consumeBool wire decodes a bool pointer as a Bool.
-func consumeBool(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Bool() = protowire.DecodeBool(v)
-	out.n = n
-	return out, nil
-}
-
-var coderBool = pointerCoderFuncs{
-	size:      sizeBool,
-	marshal:   appendBool,
-	unmarshal: consumeBool,
-	merge:     mergeBool,
-}
-
-// sizeBoolNoZero returns the size of wire encoding a bool pointer as a Bool.
-// The zero value is not encoded.
-func sizeBoolNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Bool()
-	if v == false {
-		return 0
-	}
-	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
-}
-
-// appendBoolNoZero wire encodes a bool pointer as a Bool.
-// The zero value is not encoded.
-func appendBoolNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Bool()
-	if v == false {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
-	return b, nil
-}
-
-var coderBoolNoZero = pointerCoderFuncs{
-	size:      sizeBoolNoZero,
-	marshal:   appendBoolNoZero,
-	unmarshal: consumeBool,
-	merge:     mergeBoolNoZero,
-}
-
-// sizeBoolPtr returns the size of wire encoding a *bool pointer as a Bool.
-// It panics if the pointer is nil.
-func sizeBoolPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := **p.BoolPtr()
-	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
-}
-
-// appendBoolPtr wire encodes a *bool pointer as a Bool.
-// It panics if the pointer is nil.
-func appendBoolPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.BoolPtr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
-	return b, nil
-}
-
-// consumeBoolPtr wire decodes a *bool pointer as a Bool.
-func consumeBoolPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.BoolPtr()
-	if *vp == nil {
-		*vp = new(bool)
-	}
-	**vp = protowire.DecodeBool(v)
-	out.n = n
-	return out, nil
-}
-
-var coderBoolPtr = pointerCoderFuncs{
-	size:      sizeBoolPtr,
-	marshal:   appendBoolPtr,
-	unmarshal: consumeBoolPtr,
-	merge:     mergeBoolPtr,
-}
-
-// sizeBoolSlice returns the size of wire encoding a []bool pointer as a repeated Bool.
-func sizeBoolSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.BoolSlice()
-	for _, v := range s {
-		size += f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
-	}
-	return size
-}
-
-// appendBoolSlice encodes a []bool pointer as a repeated Bool.
-func appendBoolSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.BoolSlice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendVarint(b, protowire.EncodeBool(v))
-	}
-	return b, nil
-}
-
-// consumeBoolSlice wire decodes a []bool pointer as a repeated Bool.
-func consumeBoolSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.BoolSlice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, protowire.DecodeBool(v))
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, protowire.DecodeBool(v))
-	out.n = n
-	return out, nil
-}
-
-var coderBoolSlice = pointerCoderFuncs{
-	size:      sizeBoolSlice,
-	marshal:   appendBoolSlice,
-	unmarshal: consumeBoolSlice,
-	merge:     mergeBoolSlice,
-}
-
-// sizeBoolPackedSlice returns the size of wire encoding a []bool pointer as a packed repeated Bool.
-func sizeBoolPackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.BoolSlice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(protowire.EncodeBool(v))
-	}
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendBoolPackedSlice encodes a []bool pointer as a packed repeated Bool.
-func appendBoolPackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.BoolSlice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(protowire.EncodeBool(v))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendVarint(b, protowire.EncodeBool(v))
-	}
-	return b, nil
-}
-
-var coderBoolPackedSlice = pointerCoderFuncs{
-	size:      sizeBoolPackedSlice,
-	marshal:   appendBoolPackedSlice,
-	unmarshal: consumeBoolSlice,
-	merge:     mergeBoolSlice,
-}
-
-// sizeBoolValue returns the size of wire encoding a bool value as a Bool.
-func sizeBoolValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
-}
-
-// appendBoolValue encodes a bool value as a Bool.
-func appendBoolValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
-	return b, nil
-}
-
-// consumeBoolValue decodes a bool value as a Bool.
-func consumeBoolValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfBool(protowire.DecodeBool(v)), out, nil
-}
-
-var coderBoolValue = valueCoderFuncs{
-	size:      sizeBoolValue,
-	marshal:   appendBoolValue,
-	unmarshal: consumeBoolValue,
-	merge:     mergeScalarValue,
-}
-
-// sizeBoolSliceValue returns the size of wire encoding a []bool value as a repeated Bool.
-func sizeBoolSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		size += tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
-	}
-	return size
-}
-
-// appendBoolSliceValue encodes a []bool value as a repeated Bool.
-func appendBoolSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
-	}
-	return b, nil
-}
-
-// consumeBoolSliceValue wire decodes a []bool value as a repeated Bool.
-func consumeBoolSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderBoolSliceValue = valueCoderFuncs{
-	size:      sizeBoolSliceValue,
-	marshal:   appendBoolSliceValue,
-	unmarshal: consumeBoolSliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeBoolPackedSliceValue returns the size of wire encoding a []bool value as a packed repeated Bool.
-func sizeBoolPackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := 0
-	for i, llen := 0, llen; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
-	}
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendBoolPackedSliceValue encodes a []bool value as a packed repeated Bool.
-func appendBoolPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := 0
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
-	}
-	return b, nil
-}
-
-var coderBoolPackedSliceValue = valueCoderFuncs{
-	size:      sizeBoolPackedSliceValue,
-	marshal:   appendBoolPackedSliceValue,
-	unmarshal: consumeBoolSliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeEnumValue returns the size of wire encoding a  value as a Enum.
-func sizeEnumValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeVarint(uint64(v.Enum()))
-}
-
-// appendEnumValue encodes a  value as a Enum.
-func appendEnumValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendVarint(b, uint64(v.Enum()))
-	return b, nil
-}
-
-// consumeEnumValue decodes a  value as a Enum.
-func consumeEnumValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), out, nil
-}
-
-var coderEnumValue = valueCoderFuncs{
-	size:      sizeEnumValue,
-	marshal:   appendEnumValue,
-	unmarshal: consumeEnumValue,
-	merge:     mergeScalarValue,
-}
-
-// sizeEnumSliceValue returns the size of wire encoding a [] value as a repeated Enum.
-func sizeEnumSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		size += tagsize + protowire.SizeVarint(uint64(v.Enum()))
-	}
-	return size
-}
-
-// appendEnumSliceValue encodes a [] value as a repeated Enum.
-func appendEnumSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendVarint(b, uint64(v.Enum()))
-	}
-	return b, nil
-}
-
-// consumeEnumSliceValue wire decodes a [] value as a repeated Enum.
-func consumeEnumSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderEnumSliceValue = valueCoderFuncs{
-	size:      sizeEnumSliceValue,
-	marshal:   appendEnumSliceValue,
-	unmarshal: consumeEnumSliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeEnumPackedSliceValue returns the size of wire encoding a [] value as a packed repeated Enum.
-func sizeEnumPackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := 0
-	for i, llen := 0, llen; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(uint64(v.Enum()))
-	}
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendEnumPackedSliceValue encodes a [] value as a packed repeated Enum.
-func appendEnumPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := 0
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(uint64(v.Enum()))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, uint64(v.Enum()))
-	}
-	return b, nil
-}
-
-var coderEnumPackedSliceValue = valueCoderFuncs{
-	size:      sizeEnumPackedSliceValue,
-	marshal:   appendEnumPackedSliceValue,
-	unmarshal: consumeEnumSliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeInt32 returns the size of wire encoding a int32 pointer as a Int32.
-func sizeInt32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Int32()
-	return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt32 wire encodes a int32 pointer as a Int32.
-func appendInt32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int32()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(v))
-	return b, nil
-}
-
-// consumeInt32 wire decodes a int32 pointer as a Int32.
-func consumeInt32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Int32() = int32(v)
-	out.n = n
-	return out, nil
-}
-
-var coderInt32 = pointerCoderFuncs{
-	size:      sizeInt32,
-	marshal:   appendInt32,
-	unmarshal: consumeInt32,
-	merge:     mergeInt32,
-}
-
-// sizeInt32NoZero returns the size of wire encoding a int32 pointer as a Int32.
-// The zero value is not encoded.
-func sizeInt32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Int32()
-	if v == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt32NoZero wire encodes a int32 pointer as a Int32.
-// The zero value is not encoded.
-func appendInt32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int32()
-	if v == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(v))
-	return b, nil
-}
-
-var coderInt32NoZero = pointerCoderFuncs{
-	size:      sizeInt32NoZero,
-	marshal:   appendInt32NoZero,
-	unmarshal: consumeInt32,
-	merge:     mergeInt32NoZero,
-}
-
-// sizeInt32Ptr returns the size of wire encoding a *int32 pointer as a Int32.
-// It panics if the pointer is nil.
-func sizeInt32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := **p.Int32Ptr()
-	return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt32Ptr wire encodes a *int32 pointer as a Int32.
-// It panics if the pointer is nil.
-func appendInt32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Int32Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(v))
-	return b, nil
-}
-
-// consumeInt32Ptr wire decodes a *int32 pointer as a Int32.
-func consumeInt32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Int32Ptr()
-	if *vp == nil {
-		*vp = new(int32)
-	}
-	**vp = int32(v)
-	out.n = n
-	return out, nil
-}
-
-var coderInt32Ptr = pointerCoderFuncs{
-	size:      sizeInt32Ptr,
-	marshal:   appendInt32Ptr,
-	unmarshal: consumeInt32Ptr,
-	merge:     mergeInt32Ptr,
-}
-
-// sizeInt32Slice returns the size of wire encoding a []int32 pointer as a repeated Int32.
-func sizeInt32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int32Slice()
-	for _, v := range s {
-		size += f.tagsize + protowire.SizeVarint(uint64(v))
-	}
-	return size
-}
-
-// appendInt32Slice encodes a []int32 pointer as a repeated Int32.
-func appendInt32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int32Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-
-// consumeInt32Slice wire decodes a []int32 pointer as a repeated Int32.
-func consumeInt32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Int32Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, int32(v))
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, int32(v))
-	out.n = n
-	return out, nil
-}
-
-var coderInt32Slice = pointerCoderFuncs{
-	size:      sizeInt32Slice,
-	marshal:   appendInt32Slice,
-	unmarshal: consumeInt32Slice,
-	merge:     mergeInt32Slice,
-}
-
-// sizeInt32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Int32.
-func sizeInt32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(uint64(v))
-	}
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendInt32PackedSlice encodes a []int32 pointer as a packed repeated Int32.
-func appendInt32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(uint64(v))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-
-var coderInt32PackedSlice = pointerCoderFuncs{
-	size:      sizeInt32PackedSlice,
-	marshal:   appendInt32PackedSlice,
-	unmarshal: consumeInt32Slice,
-	merge:     mergeInt32Slice,
-}
-
-// sizeInt32Value returns the size of wire encoding a int32 value as a Int32.
-func sizeInt32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
-}
-
-// appendInt32Value encodes a int32 value as a Int32.
-func appendInt32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendVarint(b, uint64(int32(v.Int())))
-	return b, nil
-}
-
-// consumeInt32Value decodes a int32 value as a Int32.
-func consumeInt32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfInt32(int32(v)), out, nil
-}
-
-var coderInt32Value = valueCoderFuncs{
-	size:      sizeInt32Value,
-	marshal:   appendInt32Value,
-	unmarshal: consumeInt32Value,
-	merge:     mergeScalarValue,
-}
-
-// sizeInt32SliceValue returns the size of wire encoding a []int32 value as a repeated Int32.
-func sizeInt32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		size += tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
-	}
-	return size
-}
-
-// appendInt32SliceValue encodes a []int32 value as a repeated Int32.
-func appendInt32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
-	}
-	return b, nil
-}
-
-// consumeInt32SliceValue wire decodes a []int32 value as a repeated Int32.
-func consumeInt32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfInt32(int32(v)))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfInt32(int32(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderInt32SliceValue = valueCoderFuncs{
-	size:      sizeInt32SliceValue,
-	marshal:   appendInt32SliceValue,
-	unmarshal: consumeInt32SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeInt32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Int32.
-func sizeInt32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := 0
-	for i, llen := 0, llen; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(uint64(int32(v.Int())))
-	}
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendInt32PackedSliceValue encodes a []int32 value as a packed repeated Int32.
-func appendInt32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := 0
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(uint64(int32(v.Int())))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
-	}
-	return b, nil
-}
-
-var coderInt32PackedSliceValue = valueCoderFuncs{
-	size:      sizeInt32PackedSliceValue,
-	marshal:   appendInt32PackedSliceValue,
-	unmarshal: consumeInt32SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeSint32 returns the size of wire encoding a int32 pointer as a Sint32.
-func sizeSint32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Int32()
-	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
-}
-
-// appendSint32 wire encodes a int32 pointer as a Sint32.
-func appendSint32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int32()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
-	return b, nil
-}
-
-// consumeSint32 wire decodes a int32 pointer as a Sint32.
-func consumeSint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Int32() = int32(protowire.DecodeZigZag(v & math.MaxUint32))
-	out.n = n
-	return out, nil
-}
-
-var coderSint32 = pointerCoderFuncs{
-	size:      sizeSint32,
-	marshal:   appendSint32,
-	unmarshal: consumeSint32,
-	merge:     mergeInt32,
-}
-
-// sizeSint32NoZero returns the size of wire encoding a int32 pointer as a Sint32.
-// The zero value is not encoded.
-func sizeSint32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Int32()
-	if v == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
-}
-
-// appendSint32NoZero wire encodes a int32 pointer as a Sint32.
-// The zero value is not encoded.
-func appendSint32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int32()
-	if v == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
-	return b, nil
-}
-
-var coderSint32NoZero = pointerCoderFuncs{
-	size:      sizeSint32NoZero,
-	marshal:   appendSint32NoZero,
-	unmarshal: consumeSint32,
-	merge:     mergeInt32NoZero,
-}
-
-// sizeSint32Ptr returns the size of wire encoding a *int32 pointer as a Sint32.
-// It panics if the pointer is nil.
-func sizeSint32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := **p.Int32Ptr()
-	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
-}
-
-// appendSint32Ptr wire encodes a *int32 pointer as a Sint32.
-// It panics if the pointer is nil.
-func appendSint32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Int32Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
-	return b, nil
-}
-
-// consumeSint32Ptr wire decodes a *int32 pointer as a Sint32.
-func consumeSint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Int32Ptr()
-	if *vp == nil {
-		*vp = new(int32)
-	}
-	**vp = int32(protowire.DecodeZigZag(v & math.MaxUint32))
-	out.n = n
-	return out, nil
-}
-
-var coderSint32Ptr = pointerCoderFuncs{
-	size:      sizeSint32Ptr,
-	marshal:   appendSint32Ptr,
-	unmarshal: consumeSint32Ptr,
-	merge:     mergeInt32Ptr,
-}
-
-// sizeSint32Slice returns the size of wire encoding a []int32 pointer as a repeated Sint32.
-func sizeSint32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int32Slice()
-	for _, v := range s {
-		size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
-	}
-	return size
-}
-
-// appendSint32Slice encodes a []int32 pointer as a repeated Sint32.
-func appendSint32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int32Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
-	}
-	return b, nil
-}
-
-// consumeSint32Slice wire decodes a []int32 pointer as a repeated Sint32.
-func consumeSint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Int32Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
-	out.n = n
-	return out, nil
-}
-
-var coderSint32Slice = pointerCoderFuncs{
-	size:      sizeSint32Slice,
-	marshal:   appendSint32Slice,
-	unmarshal: consumeSint32Slice,
-	merge:     mergeInt32Slice,
-}
-
-// sizeSint32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sint32.
-func sizeSint32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
-	}
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendSint32PackedSlice encodes a []int32 pointer as a packed repeated Sint32.
-func appendSint32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
-	}
-	return b, nil
-}
-
-var coderSint32PackedSlice = pointerCoderFuncs{
-	size:      sizeSint32PackedSlice,
-	marshal:   appendSint32PackedSlice,
-	unmarshal: consumeSint32Slice,
-	merge:     mergeInt32Slice,
-}
-
-// sizeSint32Value returns the size of wire encoding a int32 value as a Sint32.
-func sizeSint32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
-}
-
-// appendSint32Value encodes a int32 value as a Sint32.
-func appendSint32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
-	return b, nil
-}
-
-// consumeSint32Value decodes a int32 value as a Sint32.
-func consumeSint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), out, nil
-}
-
-var coderSint32Value = valueCoderFuncs{
-	size:      sizeSint32Value,
-	marshal:   appendSint32Value,
-	unmarshal: consumeSint32Value,
-	merge:     mergeScalarValue,
-}
-
-// sizeSint32SliceValue returns the size of wire encoding a []int32 value as a repeated Sint32.
-func sizeSint32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
-	}
-	return size
-}
-
-// appendSint32SliceValue encodes a []int32 value as a repeated Sint32.
-func appendSint32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
-	}
-	return b, nil
-}
-
-// consumeSint32SliceValue wire decodes a []int32 value as a repeated Sint32.
-func consumeSint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderSint32SliceValue = valueCoderFuncs{
-	size:      sizeSint32SliceValue,
-	marshal:   appendSint32SliceValue,
-	unmarshal: consumeSint32SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeSint32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Sint32.
-func sizeSint32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := 0
-	for i, llen := 0, llen; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
-	}
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendSint32PackedSliceValue encodes a []int32 value as a packed repeated Sint32.
-func appendSint32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := 0
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
-	}
-	return b, nil
-}
-
-var coderSint32PackedSliceValue = valueCoderFuncs{
-	size:      sizeSint32PackedSliceValue,
-	marshal:   appendSint32PackedSliceValue,
-	unmarshal: consumeSint32SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeUint32 returns the size of wire encoding a uint32 pointer as a Uint32.
-func sizeUint32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Uint32()
-	return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendUint32 wire encodes a uint32 pointer as a Uint32.
-func appendUint32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Uint32()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(v))
-	return b, nil
-}
-
-// consumeUint32 wire decodes a uint32 pointer as a Uint32.
-func consumeUint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Uint32() = uint32(v)
-	out.n = n
-	return out, nil
-}
-
-var coderUint32 = pointerCoderFuncs{
-	size:      sizeUint32,
-	marshal:   appendUint32,
-	unmarshal: consumeUint32,
-	merge:     mergeUint32,
-}
-
-// sizeUint32NoZero returns the size of wire encoding a uint32 pointer as a Uint32.
-// The zero value is not encoded.
-func sizeUint32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Uint32()
-	if v == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendUint32NoZero wire encodes a uint32 pointer as a Uint32.
-// The zero value is not encoded.
-func appendUint32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Uint32()
-	if v == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(v))
-	return b, nil
-}
-
-var coderUint32NoZero = pointerCoderFuncs{
-	size:      sizeUint32NoZero,
-	marshal:   appendUint32NoZero,
-	unmarshal: consumeUint32,
-	merge:     mergeUint32NoZero,
-}
-
-// sizeUint32Ptr returns the size of wire encoding a *uint32 pointer as a Uint32.
-// It panics if the pointer is nil.
-func sizeUint32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := **p.Uint32Ptr()
-	return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendUint32Ptr wire encodes a *uint32 pointer as a Uint32.
-// It panics if the pointer is nil.
-func appendUint32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Uint32Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(v))
-	return b, nil
-}
-
-// consumeUint32Ptr wire decodes a *uint32 pointer as a Uint32.
-func consumeUint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Uint32Ptr()
-	if *vp == nil {
-		*vp = new(uint32)
-	}
-	**vp = uint32(v)
-	out.n = n
-	return out, nil
-}
-
-var coderUint32Ptr = pointerCoderFuncs{
-	size:      sizeUint32Ptr,
-	marshal:   appendUint32Ptr,
-	unmarshal: consumeUint32Ptr,
-	merge:     mergeUint32Ptr,
-}
-
-// sizeUint32Slice returns the size of wire encoding a []uint32 pointer as a repeated Uint32.
-func sizeUint32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Uint32Slice()
-	for _, v := range s {
-		size += f.tagsize + protowire.SizeVarint(uint64(v))
-	}
-	return size
-}
-
-// appendUint32Slice encodes a []uint32 pointer as a repeated Uint32.
-func appendUint32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Uint32Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-
-// consumeUint32Slice wire decodes a []uint32 pointer as a repeated Uint32.
-func consumeUint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Uint32Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, uint32(v))
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, uint32(v))
-	out.n = n
-	return out, nil
-}
-
-var coderUint32Slice = pointerCoderFuncs{
-	size:      sizeUint32Slice,
-	marshal:   appendUint32Slice,
-	unmarshal: consumeUint32Slice,
-	merge:     mergeUint32Slice,
-}
-
-// sizeUint32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Uint32.
-func sizeUint32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Uint32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(uint64(v))
-	}
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendUint32PackedSlice encodes a []uint32 pointer as a packed repeated Uint32.
-func appendUint32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Uint32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(uint64(v))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-
-var coderUint32PackedSlice = pointerCoderFuncs{
-	size:      sizeUint32PackedSlice,
-	marshal:   appendUint32PackedSlice,
-	unmarshal: consumeUint32Slice,
-	merge:     mergeUint32Slice,
-}
-
-// sizeUint32Value returns the size of wire encoding a uint32 value as a Uint32.
-func sizeUint32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
-}
-
-// appendUint32Value encodes a uint32 value as a Uint32.
-func appendUint32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
-	return b, nil
-}
-
-// consumeUint32Value decodes a uint32 value as a Uint32.
-func consumeUint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfUint32(uint32(v)), out, nil
-}
-
-var coderUint32Value = valueCoderFuncs{
-	size:      sizeUint32Value,
-	marshal:   appendUint32Value,
-	unmarshal: consumeUint32Value,
-	merge:     mergeScalarValue,
-}
-
-// sizeUint32SliceValue returns the size of wire encoding a []uint32 value as a repeated Uint32.
-func sizeUint32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		size += tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
-	}
-	return size
-}
-
-// appendUint32SliceValue encodes a []uint32 value as a repeated Uint32.
-func appendUint32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
-	}
-	return b, nil
-}
-
-// consumeUint32SliceValue wire decodes a []uint32 value as a repeated Uint32.
-func consumeUint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfUint32(uint32(v)))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfUint32(uint32(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderUint32SliceValue = valueCoderFuncs{
-	size:      sizeUint32SliceValue,
-	marshal:   appendUint32SliceValue,
-	unmarshal: consumeUint32SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeUint32PackedSliceValue returns the size of wire encoding a []uint32 value as a packed repeated Uint32.
-func sizeUint32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := 0
-	for i, llen := 0, llen; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(uint64(uint32(v.Uint())))
-	}
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendUint32PackedSliceValue encodes a []uint32 value as a packed repeated Uint32.
-func appendUint32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := 0
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(uint64(uint32(v.Uint())))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
-	}
-	return b, nil
-}
-
-var coderUint32PackedSliceValue = valueCoderFuncs{
-	size:      sizeUint32PackedSliceValue,
-	marshal:   appendUint32PackedSliceValue,
-	unmarshal: consumeUint32SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeInt64 returns the size of wire encoding a int64 pointer as a Int64.
-func sizeInt64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Int64()
-	return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt64 wire encodes a int64 pointer as a Int64.
-func appendInt64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int64()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(v))
-	return b, nil
-}
-
-// consumeInt64 wire decodes a int64 pointer as a Int64.
-func consumeInt64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Int64() = int64(v)
-	out.n = n
-	return out, nil
-}
-
-var coderInt64 = pointerCoderFuncs{
-	size:      sizeInt64,
-	marshal:   appendInt64,
-	unmarshal: consumeInt64,
-	merge:     mergeInt64,
-}
-
-// sizeInt64NoZero returns the size of wire encoding a int64 pointer as a Int64.
-// The zero value is not encoded.
-func sizeInt64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Int64()
-	if v == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt64NoZero wire encodes a int64 pointer as a Int64.
-// The zero value is not encoded.
-func appendInt64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int64()
-	if v == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(v))
-	return b, nil
-}
-
-var coderInt64NoZero = pointerCoderFuncs{
-	size:      sizeInt64NoZero,
-	marshal:   appendInt64NoZero,
-	unmarshal: consumeInt64,
-	merge:     mergeInt64NoZero,
-}
-
-// sizeInt64Ptr returns the size of wire encoding a *int64 pointer as a Int64.
-// It panics if the pointer is nil.
-func sizeInt64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := **p.Int64Ptr()
-	return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-// appendInt64Ptr wire encodes a *int64 pointer as a Int64.
-// It panics if the pointer is nil.
-func appendInt64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Int64Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(v))
-	return b, nil
-}
-
-// consumeInt64Ptr wire decodes a *int64 pointer as a Int64.
-func consumeInt64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Int64Ptr()
-	if *vp == nil {
-		*vp = new(int64)
-	}
-	**vp = int64(v)
-	out.n = n
-	return out, nil
-}
-
-var coderInt64Ptr = pointerCoderFuncs{
-	size:      sizeInt64Ptr,
-	marshal:   appendInt64Ptr,
-	unmarshal: consumeInt64Ptr,
-	merge:     mergeInt64Ptr,
-}
-
-// sizeInt64Slice returns the size of wire encoding a []int64 pointer as a repeated Int64.
-func sizeInt64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int64Slice()
-	for _, v := range s {
-		size += f.tagsize + protowire.SizeVarint(uint64(v))
-	}
-	return size
-}
-
-// appendInt64Slice encodes a []int64 pointer as a repeated Int64.
-func appendInt64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int64Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-
-// consumeInt64Slice wire decodes a []int64 pointer as a repeated Int64.
-func consumeInt64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Int64Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, int64(v))
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, int64(v))
-	out.n = n
-	return out, nil
-}
-
-var coderInt64Slice = pointerCoderFuncs{
-	size:      sizeInt64Slice,
-	marshal:   appendInt64Slice,
-	unmarshal: consumeInt64Slice,
-	merge:     mergeInt64Slice,
-}
-
-// sizeInt64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Int64.
-func sizeInt64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(uint64(v))
-	}
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendInt64PackedSlice encodes a []int64 pointer as a packed repeated Int64.
-func appendInt64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(uint64(v))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendVarint(b, uint64(v))
-	}
-	return b, nil
-}
-
-var coderInt64PackedSlice = pointerCoderFuncs{
-	size:      sizeInt64PackedSlice,
-	marshal:   appendInt64PackedSlice,
-	unmarshal: consumeInt64Slice,
-	merge:     mergeInt64Slice,
-}
-
-// sizeInt64Value returns the size of wire encoding a int64 value as a Int64.
-func sizeInt64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeVarint(uint64(v.Int()))
-}
-
-// appendInt64Value encodes a int64 value as a Int64.
-func appendInt64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendVarint(b, uint64(v.Int()))
-	return b, nil
-}
-
-// consumeInt64Value decodes a int64 value as a Int64.
-func consumeInt64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfInt64(int64(v)), out, nil
-}
-
-var coderInt64Value = valueCoderFuncs{
-	size:      sizeInt64Value,
-	marshal:   appendInt64Value,
-	unmarshal: consumeInt64Value,
-	merge:     mergeScalarValue,
-}
-
-// sizeInt64SliceValue returns the size of wire encoding a []int64 value as a repeated Int64.
-func sizeInt64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		size += tagsize + protowire.SizeVarint(uint64(v.Int()))
-	}
-	return size
-}
-
-// appendInt64SliceValue encodes a []int64 value as a repeated Int64.
-func appendInt64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendVarint(b, uint64(v.Int()))
-	}
-	return b, nil
-}
-
-// consumeInt64SliceValue wire decodes a []int64 value as a repeated Int64.
-func consumeInt64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfInt64(int64(v)))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfInt64(int64(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderInt64SliceValue = valueCoderFuncs{
-	size:      sizeInt64SliceValue,
-	marshal:   appendInt64SliceValue,
-	unmarshal: consumeInt64SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeInt64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Int64.
-func sizeInt64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := 0
-	for i, llen := 0, llen; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(uint64(v.Int()))
-	}
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendInt64PackedSliceValue encodes a []int64 value as a packed repeated Int64.
-func appendInt64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := 0
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(uint64(v.Int()))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, uint64(v.Int()))
-	}
-	return b, nil
-}
-
-var coderInt64PackedSliceValue = valueCoderFuncs{
-	size:      sizeInt64PackedSliceValue,
-	marshal:   appendInt64PackedSliceValue,
-	unmarshal: consumeInt64SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeSint64 returns the size of wire encoding a int64 pointer as a Sint64.
-func sizeSint64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Int64()
-	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
-}
-
-// appendSint64 wire encodes a int64 pointer as a Sint64.
-func appendSint64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int64()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
-	return b, nil
-}
-
-// consumeSint64 wire decodes a int64 pointer as a Sint64.
-func consumeSint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Int64() = protowire.DecodeZigZag(v)
-	out.n = n
-	return out, nil
-}
-
-var coderSint64 = pointerCoderFuncs{
-	size:      sizeSint64,
-	marshal:   appendSint64,
-	unmarshal: consumeSint64,
-	merge:     mergeInt64,
-}
-
-// sizeSint64NoZero returns the size of wire encoding a int64 pointer as a Sint64.
-// The zero value is not encoded.
-func sizeSint64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Int64()
-	if v == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
-}
-
-// appendSint64NoZero wire encodes a int64 pointer as a Sint64.
-// The zero value is not encoded.
-func appendSint64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int64()
-	if v == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
-	return b, nil
-}
-
-var coderSint64NoZero = pointerCoderFuncs{
-	size:      sizeSint64NoZero,
-	marshal:   appendSint64NoZero,
-	unmarshal: consumeSint64,
-	merge:     mergeInt64NoZero,
-}
-
-// sizeSint64Ptr returns the size of wire encoding a *int64 pointer as a Sint64.
-// It panics if the pointer is nil.
-func sizeSint64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := **p.Int64Ptr()
-	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
-}
-
-// appendSint64Ptr wire encodes a *int64 pointer as a Sint64.
-// It panics if the pointer is nil.
-func appendSint64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Int64Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
-	return b, nil
-}
-
-// consumeSint64Ptr wire decodes a *int64 pointer as a Sint64.
-func consumeSint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Int64Ptr()
-	if *vp == nil {
-		*vp = new(int64)
-	}
-	**vp = protowire.DecodeZigZag(v)
-	out.n = n
-	return out, nil
-}
-
-var coderSint64Ptr = pointerCoderFuncs{
-	size:      sizeSint64Ptr,
-	marshal:   appendSint64Ptr,
-	unmarshal: consumeSint64Ptr,
-	merge:     mergeInt64Ptr,
-}
-
-// sizeSint64Slice returns the size of wire encoding a []int64 pointer as a repeated Sint64.
-func sizeSint64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int64Slice()
-	for _, v := range s {
-		size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
-	}
-	return size
-}
-
-// appendSint64Slice encodes a []int64 pointer as a repeated Sint64.
-func appendSint64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int64Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
-	}
-	return b, nil
-}
-
-// consumeSint64Slice wire decodes a []int64 pointer as a repeated Sint64.
-func consumeSint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Int64Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, protowire.DecodeZigZag(v))
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, protowire.DecodeZigZag(v))
-	out.n = n
-	return out, nil
-}
-
-var coderSint64Slice = pointerCoderFuncs{
-	size:      sizeSint64Slice,
-	marshal:   appendSint64Slice,
-	unmarshal: consumeSint64Slice,
-	merge:     mergeInt64Slice,
-}
-
-// sizeSint64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sint64.
-func sizeSint64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(protowire.EncodeZigZag(v))
-	}
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendSint64PackedSlice encodes a []int64 pointer as a packed repeated Sint64.
-func appendSint64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(protowire.EncodeZigZag(v))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
-	}
-	return b, nil
-}
-
-var coderSint64PackedSlice = pointerCoderFuncs{
-	size:      sizeSint64PackedSlice,
-	marshal:   appendSint64PackedSlice,
-	unmarshal: consumeSint64Slice,
-	merge:     mergeInt64Slice,
-}
-
-// sizeSint64Value returns the size of wire encoding a int64 value as a Sint64.
-func sizeSint64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
-}
-
-// appendSint64Value encodes a int64 value as a Sint64.
-func appendSint64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
-	return b, nil
-}
-
-// consumeSint64Value decodes a int64 value as a Sint64.
-func consumeSint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), out, nil
-}
-
-var coderSint64Value = valueCoderFuncs{
-	size:      sizeSint64Value,
-	marshal:   appendSint64Value,
-	unmarshal: consumeSint64Value,
-	merge:     mergeScalarValue,
-}
-
-// sizeSint64SliceValue returns the size of wire encoding a []int64 value as a repeated Sint64.
-func sizeSint64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
-	}
-	return size
-}
-
-// appendSint64SliceValue encodes a []int64 value as a repeated Sint64.
-func appendSint64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
-	}
-	return b, nil
-}
-
-// consumeSint64SliceValue wire decodes a []int64 value as a repeated Sint64.
-func consumeSint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderSint64SliceValue = valueCoderFuncs{
-	size:      sizeSint64SliceValue,
-	marshal:   appendSint64SliceValue,
-	unmarshal: consumeSint64SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeSint64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Sint64.
-func sizeSint64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := 0
-	for i, llen := 0, llen; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
-	}
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendSint64PackedSliceValue encodes a []int64 value as a packed repeated Sint64.
-func appendSint64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := 0
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
-	}
-	return b, nil
-}
-
-var coderSint64PackedSliceValue = valueCoderFuncs{
-	size:      sizeSint64PackedSliceValue,
-	marshal:   appendSint64PackedSliceValue,
-	unmarshal: consumeSint64SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeUint64 returns the size of wire encoding a uint64 pointer as a Uint64.
-func sizeUint64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Uint64()
-	return f.tagsize + protowire.SizeVarint(v)
-}
-
-// appendUint64 wire encodes a uint64 pointer as a Uint64.
-func appendUint64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Uint64()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, v)
-	return b, nil
-}
-
-// consumeUint64 wire decodes a uint64 pointer as a Uint64.
-func consumeUint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Uint64() = v
-	out.n = n
-	return out, nil
-}
-
-var coderUint64 = pointerCoderFuncs{
-	size:      sizeUint64,
-	marshal:   appendUint64,
-	unmarshal: consumeUint64,
-	merge:     mergeUint64,
-}
-
-// sizeUint64NoZero returns the size of wire encoding a uint64 pointer as a Uint64.
-// The zero value is not encoded.
-func sizeUint64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Uint64()
-	if v == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeVarint(v)
-}
-
-// appendUint64NoZero wire encodes a uint64 pointer as a Uint64.
-// The zero value is not encoded.
-func appendUint64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Uint64()
-	if v == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, v)
-	return b, nil
-}
-
-var coderUint64NoZero = pointerCoderFuncs{
-	size:      sizeUint64NoZero,
-	marshal:   appendUint64NoZero,
-	unmarshal: consumeUint64,
-	merge:     mergeUint64NoZero,
-}
-
-// sizeUint64Ptr returns the size of wire encoding a *uint64 pointer as a Uint64.
-// It panics if the pointer is nil.
-func sizeUint64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := **p.Uint64Ptr()
-	return f.tagsize + protowire.SizeVarint(v)
-}
-
-// appendUint64Ptr wire encodes a *uint64 pointer as a Uint64.
-// It panics if the pointer is nil.
-func appendUint64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Uint64Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, v)
-	return b, nil
-}
-
-// consumeUint64Ptr wire decodes a *uint64 pointer as a Uint64.
-func consumeUint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Uint64Ptr()
-	if *vp == nil {
-		*vp = new(uint64)
-	}
-	**vp = v
-	out.n = n
-	return out, nil
-}
-
-var coderUint64Ptr = pointerCoderFuncs{
-	size:      sizeUint64Ptr,
-	marshal:   appendUint64Ptr,
-	unmarshal: consumeUint64Ptr,
-	merge:     mergeUint64Ptr,
-}
-
-// sizeUint64Slice returns the size of wire encoding a []uint64 pointer as a repeated Uint64.
-func sizeUint64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Uint64Slice()
-	for _, v := range s {
-		size += f.tagsize + protowire.SizeVarint(v)
-	}
-	return size
-}
-
-// appendUint64Slice encodes a []uint64 pointer as a repeated Uint64.
-func appendUint64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Uint64Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendVarint(b, v)
-	}
-	return b, nil
-}
-
-// consumeUint64Slice wire decodes a []uint64 pointer as a repeated Uint64.
-func consumeUint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Uint64Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, v)
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, v)
-	out.n = n
-	return out, nil
-}
-
-var coderUint64Slice = pointerCoderFuncs{
-	size:      sizeUint64Slice,
-	marshal:   appendUint64Slice,
-	unmarshal: consumeUint64Slice,
-	merge:     mergeUint64Slice,
-}
-
-// sizeUint64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Uint64.
-func sizeUint64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Uint64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(v)
-	}
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendUint64PackedSlice encodes a []uint64 pointer as a packed repeated Uint64.
-func appendUint64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Uint64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := 0
-	for _, v := range s {
-		n += protowire.SizeVarint(v)
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendVarint(b, v)
-	}
-	return b, nil
-}
-
-var coderUint64PackedSlice = pointerCoderFuncs{
-	size:      sizeUint64PackedSlice,
-	marshal:   appendUint64PackedSlice,
-	unmarshal: consumeUint64Slice,
-	merge:     mergeUint64Slice,
-}
-
-// sizeUint64Value returns the size of wire encoding a uint64 value as a Uint64.
-func sizeUint64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeVarint(v.Uint())
-}
-
-// appendUint64Value encodes a uint64 value as a Uint64.
-func appendUint64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendVarint(b, v.Uint())
-	return b, nil
-}
-
-// consumeUint64Value decodes a uint64 value as a Uint64.
-func consumeUint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfUint64(v), out, nil
-}
-
-var coderUint64Value = valueCoderFuncs{
-	size:      sizeUint64Value,
-	marshal:   appendUint64Value,
-	unmarshal: consumeUint64Value,
-	merge:     mergeScalarValue,
-}
-
-// sizeUint64SliceValue returns the size of wire encoding a []uint64 value as a repeated Uint64.
-func sizeUint64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		size += tagsize + protowire.SizeVarint(v.Uint())
-	}
-	return size
-}
-
-// appendUint64SliceValue encodes a []uint64 value as a repeated Uint64.
-func appendUint64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendVarint(b, v.Uint())
-	}
-	return b, nil
-}
-
-// consumeUint64SliceValue wire decodes a []uint64 value as a repeated Uint64.
-func consumeUint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			var v uint64
-			var n int
-			if len(b) >= 1 && b[0] < 0x80 {
-				v = uint64(b[0])
-				n = 1
-			} else if len(b) >= 2 && b[1] < 128 {
-				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				n = 2
-			} else {
-				v, n = protowire.ConsumeVarint(b)
-			}
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfUint64(v))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	var v uint64
-	var n int
-	if len(b) >= 1 && b[0] < 0x80 {
-		v = uint64(b[0])
-		n = 1
-	} else if len(b) >= 2 && b[1] < 128 {
-		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
-		n = 2
-	} else {
-		v, n = protowire.ConsumeVarint(b)
-	}
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfUint64(v))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderUint64SliceValue = valueCoderFuncs{
-	size:      sizeUint64SliceValue,
-	marshal:   appendUint64SliceValue,
-	unmarshal: consumeUint64SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeUint64PackedSliceValue returns the size of wire encoding a []uint64 value as a packed repeated Uint64.
-func sizeUint64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := 0
-	for i, llen := 0, llen; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(v.Uint())
-	}
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendUint64PackedSliceValue encodes a []uint64 value as a packed repeated Uint64.
-func appendUint64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := 0
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		n += protowire.SizeVarint(v.Uint())
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, v.Uint())
-	}
-	return b, nil
-}
-
-var coderUint64PackedSliceValue = valueCoderFuncs{
-	size:      sizeUint64PackedSliceValue,
-	marshal:   appendUint64PackedSliceValue,
-	unmarshal: consumeUint64SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeSfixed32 returns the size of wire encoding a int32 pointer as a Sfixed32.
-func sizeSfixed32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
-	return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendSfixed32 wire encodes a int32 pointer as a Sfixed32.
-func appendSfixed32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int32()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed32(b, uint32(v))
-	return b, nil
-}
-
-// consumeSfixed32 wire decodes a int32 pointer as a Sfixed32.
-func consumeSfixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed32Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Int32() = int32(v)
-	out.n = n
-	return out, nil
-}
-
-var coderSfixed32 = pointerCoderFuncs{
-	size:      sizeSfixed32,
-	marshal:   appendSfixed32,
-	unmarshal: consumeSfixed32,
-	merge:     mergeInt32,
-}
-
-// sizeSfixed32NoZero returns the size of wire encoding a int32 pointer as a Sfixed32.
-// The zero value is not encoded.
-func sizeSfixed32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Int32()
-	if v == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendSfixed32NoZero wire encodes a int32 pointer as a Sfixed32.
-// The zero value is not encoded.
-func appendSfixed32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int32()
-	if v == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed32(b, uint32(v))
-	return b, nil
-}
-
-var coderSfixed32NoZero = pointerCoderFuncs{
-	size:      sizeSfixed32NoZero,
-	marshal:   appendSfixed32NoZero,
-	unmarshal: consumeSfixed32,
-	merge:     mergeInt32NoZero,
-}
-
-// sizeSfixed32Ptr returns the size of wire encoding a *int32 pointer as a Sfixed32.
-// It panics if the pointer is nil.
-func sizeSfixed32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendSfixed32Ptr wire encodes a *int32 pointer as a Sfixed32.
-// It panics if the pointer is nil.
-func appendSfixed32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Int32Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed32(b, uint32(v))
-	return b, nil
-}
-
-// consumeSfixed32Ptr wire decodes a *int32 pointer as a Sfixed32.
-func consumeSfixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed32Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Int32Ptr()
-	if *vp == nil {
-		*vp = new(int32)
-	}
-	**vp = int32(v)
-	out.n = n
-	return out, nil
-}
-
-var coderSfixed32Ptr = pointerCoderFuncs{
-	size:      sizeSfixed32Ptr,
-	marshal:   appendSfixed32Ptr,
-	unmarshal: consumeSfixed32Ptr,
-	merge:     mergeInt32Ptr,
-}
-
-// sizeSfixed32Slice returns the size of wire encoding a []int32 pointer as a repeated Sfixed32.
-func sizeSfixed32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int32Slice()
-	size = len(s) * (f.tagsize + protowire.SizeFixed32())
-	return size
-}
-
-// appendSfixed32Slice encodes a []int32 pointer as a repeated Sfixed32.
-func appendSfixed32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int32Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendFixed32(b, uint32(v))
-	}
-	return b, nil
-}
-
-// consumeSfixed32Slice wire decodes a []int32 pointer as a repeated Sfixed32.
-func consumeSfixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Int32Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed32(b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, int32(v))
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.Fixed32Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, int32(v))
-	out.n = n
-	return out, nil
-}
-
-var coderSfixed32Slice = pointerCoderFuncs{
-	size:      sizeSfixed32Slice,
-	marshal:   appendSfixed32Slice,
-	unmarshal: consumeSfixed32Slice,
-	merge:     mergeInt32Slice,
-}
-
-// sizeSfixed32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sfixed32.
-func sizeSfixed32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := len(s) * protowire.SizeFixed32()
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendSfixed32PackedSlice encodes a []int32 pointer as a packed repeated Sfixed32.
-func appendSfixed32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := len(s) * protowire.SizeFixed32()
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendFixed32(b, uint32(v))
-	}
-	return b, nil
-}
-
-var coderSfixed32PackedSlice = pointerCoderFuncs{
-	size:      sizeSfixed32PackedSlice,
-	marshal:   appendSfixed32PackedSlice,
-	unmarshal: consumeSfixed32Slice,
-	merge:     mergeInt32Slice,
-}
-
-// sizeSfixed32Value returns the size of wire encoding a int32 value as a Sfixed32.
-func sizeSfixed32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeFixed32()
-}
-
-// appendSfixed32Value encodes a int32 value as a Sfixed32.
-func appendSfixed32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendFixed32(b, uint32(v.Int()))
-	return b, nil
-}
-
-// consumeSfixed32Value decodes a int32 value as a Sfixed32.
-func consumeSfixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed32Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfInt32(int32(v)), out, nil
-}
-
-var coderSfixed32Value = valueCoderFuncs{
-	size:      sizeSfixed32Value,
-	marshal:   appendSfixed32Value,
-	unmarshal: consumeSfixed32Value,
-	merge:     mergeScalarValue,
-}
-
-// sizeSfixed32SliceValue returns the size of wire encoding a []int32 value as a repeated Sfixed32.
-func sizeSfixed32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	size = list.Len() * (tagsize + protowire.SizeFixed32())
-	return size
-}
-
-// appendSfixed32SliceValue encodes a []int32 value as a repeated Sfixed32.
-func appendSfixed32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendFixed32(b, uint32(v.Int()))
-	}
-	return b, nil
-}
-
-// consumeSfixed32SliceValue wire decodes a []int32 value as a repeated Sfixed32.
-func consumeSfixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed32(b)
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfInt32(int32(v)))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.Fixed32Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfInt32(int32(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderSfixed32SliceValue = valueCoderFuncs{
-	size:      sizeSfixed32SliceValue,
-	marshal:   appendSfixed32SliceValue,
-	unmarshal: consumeSfixed32SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeSfixed32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Sfixed32.
-func sizeSfixed32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := llen * protowire.SizeFixed32()
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendSfixed32PackedSliceValue encodes a []int32 value as a packed repeated Sfixed32.
-func appendSfixed32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := llen * protowire.SizeFixed32()
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendFixed32(b, uint32(v.Int()))
-	}
-	return b, nil
-}
-
-var coderSfixed32PackedSliceValue = valueCoderFuncs{
-	size:      sizeSfixed32PackedSliceValue,
-	marshal:   appendSfixed32PackedSliceValue,
-	unmarshal: consumeSfixed32SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeFixed32 returns the size of wire encoding a uint32 pointer as a Fixed32.
-func sizeFixed32(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
-	return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFixed32 wire encodes a uint32 pointer as a Fixed32.
-func appendFixed32(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Uint32()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed32(b, v)
-	return b, nil
-}
-
-// consumeFixed32 wire decodes a uint32 pointer as a Fixed32.
-func consumeFixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed32Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Uint32() = v
-	out.n = n
-	return out, nil
-}
-
-var coderFixed32 = pointerCoderFuncs{
-	size:      sizeFixed32,
-	marshal:   appendFixed32,
-	unmarshal: consumeFixed32,
-	merge:     mergeUint32,
-}
-
-// sizeFixed32NoZero returns the size of wire encoding a uint32 pointer as a Fixed32.
-// The zero value is not encoded.
-func sizeFixed32NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Uint32()
-	if v == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFixed32NoZero wire encodes a uint32 pointer as a Fixed32.
-// The zero value is not encoded.
-func appendFixed32NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Uint32()
-	if v == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed32(b, v)
-	return b, nil
-}
-
-var coderFixed32NoZero = pointerCoderFuncs{
-	size:      sizeFixed32NoZero,
-	marshal:   appendFixed32NoZero,
-	unmarshal: consumeFixed32,
-	merge:     mergeUint32NoZero,
-}
-
-// sizeFixed32Ptr returns the size of wire encoding a *uint32 pointer as a Fixed32.
-// It panics if the pointer is nil.
-func sizeFixed32Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFixed32Ptr wire encodes a *uint32 pointer as a Fixed32.
-// It panics if the pointer is nil.
-func appendFixed32Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Uint32Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed32(b, v)
-	return b, nil
-}
-
-// consumeFixed32Ptr wire decodes a *uint32 pointer as a Fixed32.
-func consumeFixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed32Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Uint32Ptr()
-	if *vp == nil {
-		*vp = new(uint32)
-	}
-	**vp = v
-	out.n = n
-	return out, nil
-}
-
-var coderFixed32Ptr = pointerCoderFuncs{
-	size:      sizeFixed32Ptr,
-	marshal:   appendFixed32Ptr,
-	unmarshal: consumeFixed32Ptr,
-	merge:     mergeUint32Ptr,
-}
-
-// sizeFixed32Slice returns the size of wire encoding a []uint32 pointer as a repeated Fixed32.
-func sizeFixed32Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Uint32Slice()
-	size = len(s) * (f.tagsize + protowire.SizeFixed32())
-	return size
-}
-
-// appendFixed32Slice encodes a []uint32 pointer as a repeated Fixed32.
-func appendFixed32Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Uint32Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendFixed32(b, v)
-	}
-	return b, nil
-}
-
-// consumeFixed32Slice wire decodes a []uint32 pointer as a repeated Fixed32.
-func consumeFixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Uint32Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed32(b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, v)
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.Fixed32Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, v)
-	out.n = n
-	return out, nil
-}
-
-var coderFixed32Slice = pointerCoderFuncs{
-	size:      sizeFixed32Slice,
-	marshal:   appendFixed32Slice,
-	unmarshal: consumeFixed32Slice,
-	merge:     mergeUint32Slice,
-}
-
-// sizeFixed32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Fixed32.
-func sizeFixed32PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Uint32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := len(s) * protowire.SizeFixed32()
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendFixed32PackedSlice encodes a []uint32 pointer as a packed repeated Fixed32.
-func appendFixed32PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Uint32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := len(s) * protowire.SizeFixed32()
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendFixed32(b, v)
-	}
-	return b, nil
-}
-
-var coderFixed32PackedSlice = pointerCoderFuncs{
-	size:      sizeFixed32PackedSlice,
-	marshal:   appendFixed32PackedSlice,
-	unmarshal: consumeFixed32Slice,
-	merge:     mergeUint32Slice,
-}
-
-// sizeFixed32Value returns the size of wire encoding a uint32 value as a Fixed32.
-func sizeFixed32Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeFixed32()
-}
-
-// appendFixed32Value encodes a uint32 value as a Fixed32.
-func appendFixed32Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendFixed32(b, uint32(v.Uint()))
-	return b, nil
-}
-
-// consumeFixed32Value decodes a uint32 value as a Fixed32.
-func consumeFixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed32Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfUint32(uint32(v)), out, nil
-}
-
-var coderFixed32Value = valueCoderFuncs{
-	size:      sizeFixed32Value,
-	marshal:   appendFixed32Value,
-	unmarshal: consumeFixed32Value,
-	merge:     mergeScalarValue,
-}
-
-// sizeFixed32SliceValue returns the size of wire encoding a []uint32 value as a repeated Fixed32.
-func sizeFixed32SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	size = list.Len() * (tagsize + protowire.SizeFixed32())
-	return size
-}
-
-// appendFixed32SliceValue encodes a []uint32 value as a repeated Fixed32.
-func appendFixed32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendFixed32(b, uint32(v.Uint()))
-	}
-	return b, nil
-}
-
-// consumeFixed32SliceValue wire decodes a []uint32 value as a repeated Fixed32.
-func consumeFixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed32(b)
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfUint32(uint32(v)))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.Fixed32Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfUint32(uint32(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderFixed32SliceValue = valueCoderFuncs{
-	size:      sizeFixed32SliceValue,
-	marshal:   appendFixed32SliceValue,
-	unmarshal: consumeFixed32SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeFixed32PackedSliceValue returns the size of wire encoding a []uint32 value as a packed repeated Fixed32.
-func sizeFixed32PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := llen * protowire.SizeFixed32()
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendFixed32PackedSliceValue encodes a []uint32 value as a packed repeated Fixed32.
-func appendFixed32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := llen * protowire.SizeFixed32()
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendFixed32(b, uint32(v.Uint()))
-	}
-	return b, nil
-}
-
-var coderFixed32PackedSliceValue = valueCoderFuncs{
-	size:      sizeFixed32PackedSliceValue,
-	marshal:   appendFixed32PackedSliceValue,
-	unmarshal: consumeFixed32SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeFloat returns the size of wire encoding a float32 pointer as a Float.
-func sizeFloat(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
-	return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFloat wire encodes a float32 pointer as a Float.
-func appendFloat(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Float32()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed32(b, math.Float32bits(v))
-	return b, nil
-}
-
-// consumeFloat wire decodes a float32 pointer as a Float.
-func consumeFloat(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed32Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Float32() = math.Float32frombits(v)
-	out.n = n
-	return out, nil
-}
-
-var coderFloat = pointerCoderFuncs{
-	size:      sizeFloat,
-	marshal:   appendFloat,
-	unmarshal: consumeFloat,
-	merge:     mergeFloat32,
-}
-
-// sizeFloatNoZero returns the size of wire encoding a float32 pointer as a Float.
-// The zero value is not encoded.
-func sizeFloatNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Float32()
-	if v == 0 && !math.Signbit(float64(v)) {
-		return 0
-	}
-	return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFloatNoZero wire encodes a float32 pointer as a Float.
-// The zero value is not encoded.
-func appendFloatNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Float32()
-	if v == 0 && !math.Signbit(float64(v)) {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed32(b, math.Float32bits(v))
-	return b, nil
-}
-
-var coderFloatNoZero = pointerCoderFuncs{
-	size:      sizeFloatNoZero,
-	marshal:   appendFloatNoZero,
-	unmarshal: consumeFloat,
-	merge:     mergeFloat32NoZero,
-}
-
-// sizeFloatPtr returns the size of wire encoding a *float32 pointer as a Float.
-// It panics if the pointer is nil.
-func sizeFloatPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + protowire.SizeFixed32()
-}
-
-// appendFloatPtr wire encodes a *float32 pointer as a Float.
-// It panics if the pointer is nil.
-func appendFloatPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Float32Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed32(b, math.Float32bits(v))
-	return b, nil
-}
-
-// consumeFloatPtr wire decodes a *float32 pointer as a Float.
-func consumeFloatPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed32Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Float32Ptr()
-	if *vp == nil {
-		*vp = new(float32)
-	}
-	**vp = math.Float32frombits(v)
-	out.n = n
-	return out, nil
-}
-
-var coderFloatPtr = pointerCoderFuncs{
-	size:      sizeFloatPtr,
-	marshal:   appendFloatPtr,
-	unmarshal: consumeFloatPtr,
-	merge:     mergeFloat32Ptr,
-}
-
-// sizeFloatSlice returns the size of wire encoding a []float32 pointer as a repeated Float.
-func sizeFloatSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Float32Slice()
-	size = len(s) * (f.tagsize + protowire.SizeFixed32())
-	return size
-}
-
-// appendFloatSlice encodes a []float32 pointer as a repeated Float.
-func appendFloatSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Float32Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendFixed32(b, math.Float32bits(v))
-	}
-	return b, nil
-}
-
-// consumeFloatSlice wire decodes a []float32 pointer as a repeated Float.
-func consumeFloatSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Float32Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed32(b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, math.Float32frombits(v))
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.Fixed32Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, math.Float32frombits(v))
-	out.n = n
-	return out, nil
-}
-
-var coderFloatSlice = pointerCoderFuncs{
-	size:      sizeFloatSlice,
-	marshal:   appendFloatSlice,
-	unmarshal: consumeFloatSlice,
-	merge:     mergeFloat32Slice,
-}
-
-// sizeFloatPackedSlice returns the size of wire encoding a []float32 pointer as a packed repeated Float.
-func sizeFloatPackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Float32Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := len(s) * protowire.SizeFixed32()
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendFloatPackedSlice encodes a []float32 pointer as a packed repeated Float.
-func appendFloatPackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Float32Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := len(s) * protowire.SizeFixed32()
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendFixed32(b, math.Float32bits(v))
-	}
-	return b, nil
-}
-
-var coderFloatPackedSlice = pointerCoderFuncs{
-	size:      sizeFloatPackedSlice,
-	marshal:   appendFloatPackedSlice,
-	unmarshal: consumeFloatSlice,
-	merge:     mergeFloat32Slice,
-}
-
-// sizeFloatValue returns the size of wire encoding a float32 value as a Float.
-func sizeFloatValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeFixed32()
-}
-
-// appendFloatValue encodes a float32 value as a Float.
-func appendFloatValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
-	return b, nil
-}
-
-// consumeFloatValue decodes a float32 value as a Float.
-func consumeFloatValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed32Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), out, nil
-}
-
-var coderFloatValue = valueCoderFuncs{
-	size:      sizeFloatValue,
-	marshal:   appendFloatValue,
-	unmarshal: consumeFloatValue,
-	merge:     mergeScalarValue,
-}
-
-// sizeFloatSliceValue returns the size of wire encoding a []float32 value as a repeated Float.
-func sizeFloatSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	size = list.Len() * (tagsize + protowire.SizeFixed32())
-	return size
-}
-
-// appendFloatSliceValue encodes a []float32 value as a repeated Float.
-func appendFloatSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
-	}
-	return b, nil
-}
-
-// consumeFloatSliceValue wire decodes a []float32 value as a repeated Float.
-func consumeFloatSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed32(b)
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.Fixed32Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed32(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderFloatSliceValue = valueCoderFuncs{
-	size:      sizeFloatSliceValue,
-	marshal:   appendFloatSliceValue,
-	unmarshal: consumeFloatSliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeFloatPackedSliceValue returns the size of wire encoding a []float32 value as a packed repeated Float.
-func sizeFloatPackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := llen * protowire.SizeFixed32()
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendFloatPackedSliceValue encodes a []float32 value as a packed repeated Float.
-func appendFloatPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := llen * protowire.SizeFixed32()
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
-	}
-	return b, nil
-}
-
-var coderFloatPackedSliceValue = valueCoderFuncs{
-	size:      sizeFloatPackedSliceValue,
-	marshal:   appendFloatPackedSliceValue,
-	unmarshal: consumeFloatSliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeSfixed64 returns the size of wire encoding a int64 pointer as a Sfixed64.
-func sizeSfixed64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
-	return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendSfixed64 wire encodes a int64 pointer as a Sfixed64.
-func appendSfixed64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int64()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed64(b, uint64(v))
-	return b, nil
-}
-
-// consumeSfixed64 wire decodes a int64 pointer as a Sfixed64.
-func consumeSfixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed64Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Int64() = int64(v)
-	out.n = n
-	return out, nil
-}
-
-var coderSfixed64 = pointerCoderFuncs{
-	size:      sizeSfixed64,
-	marshal:   appendSfixed64,
-	unmarshal: consumeSfixed64,
-	merge:     mergeInt64,
-}
-
-// sizeSfixed64NoZero returns the size of wire encoding a int64 pointer as a Sfixed64.
-// The zero value is not encoded.
-func sizeSfixed64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Int64()
-	if v == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendSfixed64NoZero wire encodes a int64 pointer as a Sfixed64.
-// The zero value is not encoded.
-func appendSfixed64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Int64()
-	if v == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed64(b, uint64(v))
-	return b, nil
-}
-
-var coderSfixed64NoZero = pointerCoderFuncs{
-	size:      sizeSfixed64NoZero,
-	marshal:   appendSfixed64NoZero,
-	unmarshal: consumeSfixed64,
-	merge:     mergeInt64NoZero,
-}
-
-// sizeSfixed64Ptr returns the size of wire encoding a *int64 pointer as a Sfixed64.
-// It panics if the pointer is nil.
-func sizeSfixed64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendSfixed64Ptr wire encodes a *int64 pointer as a Sfixed64.
-// It panics if the pointer is nil.
-func appendSfixed64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Int64Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed64(b, uint64(v))
-	return b, nil
-}
-
-// consumeSfixed64Ptr wire decodes a *int64 pointer as a Sfixed64.
-func consumeSfixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed64Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Int64Ptr()
-	if *vp == nil {
-		*vp = new(int64)
-	}
-	**vp = int64(v)
-	out.n = n
-	return out, nil
-}
-
-var coderSfixed64Ptr = pointerCoderFuncs{
-	size:      sizeSfixed64Ptr,
-	marshal:   appendSfixed64Ptr,
-	unmarshal: consumeSfixed64Ptr,
-	merge:     mergeInt64Ptr,
-}
-
-// sizeSfixed64Slice returns the size of wire encoding a []int64 pointer as a repeated Sfixed64.
-func sizeSfixed64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int64Slice()
-	size = len(s) * (f.tagsize + protowire.SizeFixed64())
-	return size
-}
-
-// appendSfixed64Slice encodes a []int64 pointer as a repeated Sfixed64.
-func appendSfixed64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int64Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendFixed64(b, uint64(v))
-	}
-	return b, nil
-}
-
-// consumeSfixed64Slice wire decodes a []int64 pointer as a repeated Sfixed64.
-func consumeSfixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Int64Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed64(b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, int64(v))
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.Fixed64Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, int64(v))
-	out.n = n
-	return out, nil
-}
-
-var coderSfixed64Slice = pointerCoderFuncs{
-	size:      sizeSfixed64Slice,
-	marshal:   appendSfixed64Slice,
-	unmarshal: consumeSfixed64Slice,
-	merge:     mergeInt64Slice,
-}
-
-// sizeSfixed64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sfixed64.
-func sizeSfixed64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Int64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := len(s) * protowire.SizeFixed64()
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendSfixed64PackedSlice encodes a []int64 pointer as a packed repeated Sfixed64.
-func appendSfixed64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Int64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := len(s) * protowire.SizeFixed64()
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendFixed64(b, uint64(v))
-	}
-	return b, nil
-}
-
-var coderSfixed64PackedSlice = pointerCoderFuncs{
-	size:      sizeSfixed64PackedSlice,
-	marshal:   appendSfixed64PackedSlice,
-	unmarshal: consumeSfixed64Slice,
-	merge:     mergeInt64Slice,
-}
-
-// sizeSfixed64Value returns the size of wire encoding a int64 value as a Sfixed64.
-func sizeSfixed64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeFixed64()
-}
-
-// appendSfixed64Value encodes a int64 value as a Sfixed64.
-func appendSfixed64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendFixed64(b, uint64(v.Int()))
-	return b, nil
-}
-
-// consumeSfixed64Value decodes a int64 value as a Sfixed64.
-func consumeSfixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed64Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfInt64(int64(v)), out, nil
-}
-
-var coderSfixed64Value = valueCoderFuncs{
-	size:      sizeSfixed64Value,
-	marshal:   appendSfixed64Value,
-	unmarshal: consumeSfixed64Value,
-	merge:     mergeScalarValue,
-}
-
-// sizeSfixed64SliceValue returns the size of wire encoding a []int64 value as a repeated Sfixed64.
-func sizeSfixed64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	size = list.Len() * (tagsize + protowire.SizeFixed64())
-	return size
-}
-
-// appendSfixed64SliceValue encodes a []int64 value as a repeated Sfixed64.
-func appendSfixed64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendFixed64(b, uint64(v.Int()))
-	}
-	return b, nil
-}
-
-// consumeSfixed64SliceValue wire decodes a []int64 value as a repeated Sfixed64.
-func consumeSfixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed64(b)
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfInt64(int64(v)))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.Fixed64Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfInt64(int64(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderSfixed64SliceValue = valueCoderFuncs{
-	size:      sizeSfixed64SliceValue,
-	marshal:   appendSfixed64SliceValue,
-	unmarshal: consumeSfixed64SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeSfixed64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Sfixed64.
-func sizeSfixed64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := llen * protowire.SizeFixed64()
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendSfixed64PackedSliceValue encodes a []int64 value as a packed repeated Sfixed64.
-func appendSfixed64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := llen * protowire.SizeFixed64()
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendFixed64(b, uint64(v.Int()))
-	}
-	return b, nil
-}
-
-var coderSfixed64PackedSliceValue = valueCoderFuncs{
-	size:      sizeSfixed64PackedSliceValue,
-	marshal:   appendSfixed64PackedSliceValue,
-	unmarshal: consumeSfixed64SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeFixed64 returns the size of wire encoding a uint64 pointer as a Fixed64.
-func sizeFixed64(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
-	return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendFixed64 wire encodes a uint64 pointer as a Fixed64.
-func appendFixed64(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Uint64()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed64(b, v)
-	return b, nil
-}
-
-// consumeFixed64 wire decodes a uint64 pointer as a Fixed64.
-func consumeFixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed64Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Uint64() = v
-	out.n = n
-	return out, nil
-}
-
-var coderFixed64 = pointerCoderFuncs{
-	size:      sizeFixed64,
-	marshal:   appendFixed64,
-	unmarshal: consumeFixed64,
-	merge:     mergeUint64,
-}
-
-// sizeFixed64NoZero returns the size of wire encoding a uint64 pointer as a Fixed64.
-// The zero value is not encoded.
-func sizeFixed64NoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Uint64()
-	if v == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendFixed64NoZero wire encodes a uint64 pointer as a Fixed64.
-// The zero value is not encoded.
-func appendFixed64NoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Uint64()
-	if v == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed64(b, v)
-	return b, nil
-}
-
-var coderFixed64NoZero = pointerCoderFuncs{
-	size:      sizeFixed64NoZero,
-	marshal:   appendFixed64NoZero,
-	unmarshal: consumeFixed64,
-	merge:     mergeUint64NoZero,
-}
-
-// sizeFixed64Ptr returns the size of wire encoding a *uint64 pointer as a Fixed64.
-// It panics if the pointer is nil.
-func sizeFixed64Ptr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendFixed64Ptr wire encodes a *uint64 pointer as a Fixed64.
-// It panics if the pointer is nil.
-func appendFixed64Ptr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Uint64Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed64(b, v)
-	return b, nil
-}
-
-// consumeFixed64Ptr wire decodes a *uint64 pointer as a Fixed64.
-func consumeFixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed64Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Uint64Ptr()
-	if *vp == nil {
-		*vp = new(uint64)
-	}
-	**vp = v
-	out.n = n
-	return out, nil
-}
-
-var coderFixed64Ptr = pointerCoderFuncs{
-	size:      sizeFixed64Ptr,
-	marshal:   appendFixed64Ptr,
-	unmarshal: consumeFixed64Ptr,
-	merge:     mergeUint64Ptr,
-}
-
-// sizeFixed64Slice returns the size of wire encoding a []uint64 pointer as a repeated Fixed64.
-func sizeFixed64Slice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Uint64Slice()
-	size = len(s) * (f.tagsize + protowire.SizeFixed64())
-	return size
-}
-
-// appendFixed64Slice encodes a []uint64 pointer as a repeated Fixed64.
-func appendFixed64Slice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Uint64Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendFixed64(b, v)
-	}
-	return b, nil
-}
-
-// consumeFixed64Slice wire decodes a []uint64 pointer as a repeated Fixed64.
-func consumeFixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Uint64Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed64(b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, v)
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.Fixed64Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, v)
-	out.n = n
-	return out, nil
-}
-
-var coderFixed64Slice = pointerCoderFuncs{
-	size:      sizeFixed64Slice,
-	marshal:   appendFixed64Slice,
-	unmarshal: consumeFixed64Slice,
-	merge:     mergeUint64Slice,
-}
-
-// sizeFixed64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Fixed64.
-func sizeFixed64PackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Uint64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := len(s) * protowire.SizeFixed64()
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendFixed64PackedSlice encodes a []uint64 pointer as a packed repeated Fixed64.
-func appendFixed64PackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Uint64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := len(s) * protowire.SizeFixed64()
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendFixed64(b, v)
-	}
-	return b, nil
-}
-
-var coderFixed64PackedSlice = pointerCoderFuncs{
-	size:      sizeFixed64PackedSlice,
-	marshal:   appendFixed64PackedSlice,
-	unmarshal: consumeFixed64Slice,
-	merge:     mergeUint64Slice,
-}
-
-// sizeFixed64Value returns the size of wire encoding a uint64 value as a Fixed64.
-func sizeFixed64Value(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeFixed64()
-}
-
-// appendFixed64Value encodes a uint64 value as a Fixed64.
-func appendFixed64Value(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendFixed64(b, v.Uint())
-	return b, nil
-}
-
-// consumeFixed64Value decodes a uint64 value as a Fixed64.
-func consumeFixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed64Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfUint64(v), out, nil
-}
-
-var coderFixed64Value = valueCoderFuncs{
-	size:      sizeFixed64Value,
-	marshal:   appendFixed64Value,
-	unmarshal: consumeFixed64Value,
-	merge:     mergeScalarValue,
-}
-
-// sizeFixed64SliceValue returns the size of wire encoding a []uint64 value as a repeated Fixed64.
-func sizeFixed64SliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	size = list.Len() * (tagsize + protowire.SizeFixed64())
-	return size
-}
-
-// appendFixed64SliceValue encodes a []uint64 value as a repeated Fixed64.
-func appendFixed64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendFixed64(b, v.Uint())
-	}
-	return b, nil
-}
-
-// consumeFixed64SliceValue wire decodes a []uint64 value as a repeated Fixed64.
-func consumeFixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed64(b)
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfUint64(v))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.Fixed64Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfUint64(v))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderFixed64SliceValue = valueCoderFuncs{
-	size:      sizeFixed64SliceValue,
-	marshal:   appendFixed64SliceValue,
-	unmarshal: consumeFixed64SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeFixed64PackedSliceValue returns the size of wire encoding a []uint64 value as a packed repeated Fixed64.
-func sizeFixed64PackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := llen * protowire.SizeFixed64()
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendFixed64PackedSliceValue encodes a []uint64 value as a packed repeated Fixed64.
-func appendFixed64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := llen * protowire.SizeFixed64()
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendFixed64(b, v.Uint())
-	}
-	return b, nil
-}
-
-var coderFixed64PackedSliceValue = valueCoderFuncs{
-	size:      sizeFixed64PackedSliceValue,
-	marshal:   appendFixed64PackedSliceValue,
-	unmarshal: consumeFixed64SliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeDouble returns the size of wire encoding a float64 pointer as a Double.
-func sizeDouble(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-
-	return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendDouble wire encodes a float64 pointer as a Double.
-func appendDouble(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Float64()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed64(b, math.Float64bits(v))
-	return b, nil
-}
-
-// consumeDouble wire decodes a float64 pointer as a Double.
-func consumeDouble(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed64Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Float64() = math.Float64frombits(v)
-	out.n = n
-	return out, nil
-}
-
-var coderDouble = pointerCoderFuncs{
-	size:      sizeDouble,
-	marshal:   appendDouble,
-	unmarshal: consumeDouble,
-	merge:     mergeFloat64,
-}
-
-// sizeDoubleNoZero returns the size of wire encoding a float64 pointer as a Double.
-// The zero value is not encoded.
-func sizeDoubleNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Float64()
-	if v == 0 && !math.Signbit(float64(v)) {
-		return 0
-	}
-	return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendDoubleNoZero wire encodes a float64 pointer as a Double.
-// The zero value is not encoded.
-func appendDoubleNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Float64()
-	if v == 0 && !math.Signbit(float64(v)) {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed64(b, math.Float64bits(v))
-	return b, nil
-}
-
-var coderDoubleNoZero = pointerCoderFuncs{
-	size:      sizeDoubleNoZero,
-	marshal:   appendDoubleNoZero,
-	unmarshal: consumeDouble,
-	merge:     mergeFloat64NoZero,
-}
-
-// sizeDoublePtr returns the size of wire encoding a *float64 pointer as a Double.
-// It panics if the pointer is nil.
-func sizeDoublePtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	return f.tagsize + protowire.SizeFixed64()
-}
-
-// appendDoublePtr wire encodes a *float64 pointer as a Double.
-// It panics if the pointer is nil.
-func appendDoublePtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.Float64Ptr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendFixed64(b, math.Float64bits(v))
-	return b, nil
-}
-
-// consumeDoublePtr wire decodes a *float64 pointer as a Double.
-func consumeDoublePtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed64Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.Float64Ptr()
-	if *vp == nil {
-		*vp = new(float64)
-	}
-	**vp = math.Float64frombits(v)
-	out.n = n
-	return out, nil
-}
-
-var coderDoublePtr = pointerCoderFuncs{
-	size:      sizeDoublePtr,
-	marshal:   appendDoublePtr,
-	unmarshal: consumeDoublePtr,
-	merge:     mergeFloat64Ptr,
-}
-
-// sizeDoubleSlice returns the size of wire encoding a []float64 pointer as a repeated Double.
-func sizeDoubleSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Float64Slice()
-	size = len(s) * (f.tagsize + protowire.SizeFixed64())
-	return size
-}
-
-// appendDoubleSlice encodes a []float64 pointer as a repeated Double.
-func appendDoubleSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Float64Slice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendFixed64(b, math.Float64bits(v))
-	}
-	return b, nil
-}
-
-// consumeDoubleSlice wire decodes a []float64 pointer as a repeated Double.
-func consumeDoubleSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.Float64Slice()
-	if wtyp == protowire.BytesType {
-		s := *sp
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed64(b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			s = append(s, math.Float64frombits(v))
-			b = b[n:]
-		}
-		*sp = s
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.Fixed64Type {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, math.Float64frombits(v))
-	out.n = n
-	return out, nil
-}
-
-var coderDoubleSlice = pointerCoderFuncs{
-	size:      sizeDoubleSlice,
-	marshal:   appendDoubleSlice,
-	unmarshal: consumeDoubleSlice,
-	merge:     mergeFloat64Slice,
-}
-
-// sizeDoublePackedSlice returns the size of wire encoding a []float64 pointer as a packed repeated Double.
-func sizeDoublePackedSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.Float64Slice()
-	if len(s) == 0 {
-		return 0
-	}
-	n := len(s) * protowire.SizeFixed64()
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-// appendDoublePackedSlice encodes a []float64 pointer as a packed repeated Double.
-func appendDoublePackedSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.Float64Slice()
-	if len(s) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := len(s) * protowire.SizeFixed64()
-	b = protowire.AppendVarint(b, uint64(n))
-	for _, v := range s {
-		b = protowire.AppendFixed64(b, math.Float64bits(v))
-	}
-	return b, nil
-}
-
-var coderDoublePackedSlice = pointerCoderFuncs{
-	size:      sizeDoublePackedSlice,
-	marshal:   appendDoublePackedSlice,
-	unmarshal: consumeDoubleSlice,
-	merge:     mergeFloat64Slice,
-}
-
-// sizeDoubleValue returns the size of wire encoding a float64 value as a Double.
-func sizeDoubleValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeFixed64()
-}
-
-// appendDoubleValue encodes a float64 value as a Double.
-func appendDoubleValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
-	return b, nil
-}
-
-// consumeDoubleValue decodes a float64 value as a Double.
-func consumeDoubleValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.Fixed64Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfFloat64(math.Float64frombits(v)), out, nil
-}
-
-var coderDoubleValue = valueCoderFuncs{
-	size:      sizeDoubleValue,
-	marshal:   appendDoubleValue,
-	unmarshal: consumeDoubleValue,
-	merge:     mergeScalarValue,
-}
-
-// sizeDoubleSliceValue returns the size of wire encoding a []float64 value as a repeated Double.
-func sizeDoubleSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	size = list.Len() * (tagsize + protowire.SizeFixed64())
-	return size
-}
-
-// appendDoubleSliceValue encodes a []float64 value as a repeated Double.
-func appendDoubleSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
-	}
-	return b, nil
-}
-
-// consumeDoubleSliceValue wire decodes a []float64 value as a repeated Double.
-func consumeDoubleSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return protoreflect.Value{}, out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeFixed64(b)
-			if n < 0 {
-				return protoreflect.Value{}, out, protowire.ParseError(n)
-			}
-			list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
-			b = b[n:]
-		}
-		out.n = n
-		return listv, out, nil
-	}
-	if wtyp != protowire.Fixed64Type {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeFixed64(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderDoubleSliceValue = valueCoderFuncs{
-	size:      sizeDoubleSliceValue,
-	marshal:   appendDoubleSliceValue,
-	unmarshal: consumeDoubleSliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeDoublePackedSliceValue returns the size of wire encoding a []float64 value as a packed repeated Double.
-func sizeDoublePackedSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := llen * protowire.SizeFixed64()
-	return tagsize + protowire.SizeBytes(n)
-}
-
-// appendDoublePackedSliceValue encodes a []float64 value as a packed repeated Double.
-func appendDoublePackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	llen := list.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, wiretag)
-	n := llen * protowire.SizeFixed64()
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
-	}
-	return b, nil
-}
-
-var coderDoublePackedSliceValue = valueCoderFuncs{
-	size:      sizeDoublePackedSliceValue,
-	marshal:   appendDoublePackedSliceValue,
-	unmarshal: consumeDoubleSliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeString returns the size of wire encoding a string pointer as a String.
-func sizeString(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.String()
-	return f.tagsize + protowire.SizeBytes(len(v))
-}
-
-// appendString wire encodes a string pointer as a String.
-func appendString(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.String()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendString(b, v)
-	return b, nil
-}
-
-// consumeString wire decodes a string pointer as a String.
-func consumeString(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeString(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.String() = v
-	out.n = n
-	return out, nil
-}
-
-var coderString = pointerCoderFuncs{
-	size:      sizeString,
-	marshal:   appendString,
-	unmarshal: consumeString,
-	merge:     mergeString,
-}
-
-// appendStringValidateUTF8 wire encodes a string pointer as a String.
-func appendStringValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.String()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendString(b, v)
-	if !utf8.ValidString(v) {
-		return b, errInvalidUTF8{}
-	}
-	return b, nil
-}
-
-// consumeStringValidateUTF8 wire decodes a string pointer as a String.
-func consumeStringValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeString(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	if !utf8.ValidString(v) {
-		return out, errInvalidUTF8{}
-	}
-	*p.String() = v
-	out.n = n
-	return out, nil
-}
-
-var coderStringValidateUTF8 = pointerCoderFuncs{
-	size:      sizeString,
-	marshal:   appendStringValidateUTF8,
-	unmarshal: consumeStringValidateUTF8,
-	merge:     mergeString,
-}
-
-// sizeStringNoZero returns the size of wire encoding a string pointer as a String.
-// The zero value is not encoded.
-func sizeStringNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.String()
-	if len(v) == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeBytes(len(v))
-}
-
-// appendStringNoZero wire encodes a string pointer as a String.
-// The zero value is not encoded.
-func appendStringNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.String()
-	if len(v) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendString(b, v)
-	return b, nil
-}
-
-var coderStringNoZero = pointerCoderFuncs{
-	size:      sizeStringNoZero,
-	marshal:   appendStringNoZero,
-	unmarshal: consumeString,
-	merge:     mergeStringNoZero,
-}
-
-// appendStringNoZeroValidateUTF8 wire encodes a string pointer as a String.
-// The zero value is not encoded.
-func appendStringNoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.String()
-	if len(v) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendString(b, v)
-	if !utf8.ValidString(v) {
-		return b, errInvalidUTF8{}
-	}
-	return b, nil
-}
-
-var coderStringNoZeroValidateUTF8 = pointerCoderFuncs{
-	size:      sizeStringNoZero,
-	marshal:   appendStringNoZeroValidateUTF8,
-	unmarshal: consumeStringValidateUTF8,
-	merge:     mergeStringNoZero,
-}
-
-// sizeStringPtr returns the size of wire encoding a *string pointer as a String.
-// It panics if the pointer is nil.
-func sizeStringPtr(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := **p.StringPtr()
-	return f.tagsize + protowire.SizeBytes(len(v))
-}
-
-// appendStringPtr wire encodes a *string pointer as a String.
-// It panics if the pointer is nil.
-func appendStringPtr(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.StringPtr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendString(b, v)
-	return b, nil
-}
-
-// consumeStringPtr wire decodes a *string pointer as a String.
-func consumeStringPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeString(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	vp := p.StringPtr()
-	if *vp == nil {
-		*vp = new(string)
-	}
-	**vp = v
-	out.n = n
-	return out, nil
-}
-
-var coderStringPtr = pointerCoderFuncs{
-	size:      sizeStringPtr,
-	marshal:   appendStringPtr,
-	unmarshal: consumeStringPtr,
-	merge:     mergeStringPtr,
-}
-
-// appendStringPtrValidateUTF8 wire encodes a *string pointer as a String.
-// It panics if the pointer is nil.
-func appendStringPtrValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := **p.StringPtr()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendString(b, v)
-	if !utf8.ValidString(v) {
-		return b, errInvalidUTF8{}
-	}
-	return b, nil
-}
-
-// consumeStringPtrValidateUTF8 wire decodes a *string pointer as a String.
-func consumeStringPtrValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeString(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	if !utf8.ValidString(v) {
-		return out, errInvalidUTF8{}
-	}
-	vp := p.StringPtr()
-	if *vp == nil {
-		*vp = new(string)
-	}
-	**vp = v
-	out.n = n
-	return out, nil
-}
-
-var coderStringPtrValidateUTF8 = pointerCoderFuncs{
-	size:      sizeStringPtr,
-	marshal:   appendStringPtrValidateUTF8,
-	unmarshal: consumeStringPtrValidateUTF8,
-	merge:     mergeStringPtr,
-}
-
-// sizeStringSlice returns the size of wire encoding a []string pointer as a repeated String.
-func sizeStringSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.StringSlice()
-	for _, v := range s {
-		size += f.tagsize + protowire.SizeBytes(len(v))
-	}
-	return size
-}
-
-// appendStringSlice encodes a []string pointer as a repeated String.
-func appendStringSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.StringSlice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendString(b, v)
-	}
-	return b, nil
-}
-
-// consumeStringSlice wire decodes a []string pointer as a repeated String.
-func consumeStringSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.StringSlice()
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeString(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, v)
-	out.n = n
-	return out, nil
-}
-
-var coderStringSlice = pointerCoderFuncs{
-	size:      sizeStringSlice,
-	marshal:   appendStringSlice,
-	unmarshal: consumeStringSlice,
-	merge:     mergeStringSlice,
-}
-
-// appendStringSliceValidateUTF8 encodes a []string pointer as a repeated String.
-func appendStringSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.StringSlice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendString(b, v)
-		if !utf8.ValidString(v) {
-			return b, errInvalidUTF8{}
-		}
-	}
-	return b, nil
-}
-
-// consumeStringSliceValidateUTF8 wire decodes a []string pointer as a repeated String.
-func consumeStringSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.StringSlice()
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeString(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	if !utf8.ValidString(v) {
-		return out, errInvalidUTF8{}
-	}
-	*sp = append(*sp, v)
-	out.n = n
-	return out, nil
-}
-
-var coderStringSliceValidateUTF8 = pointerCoderFuncs{
-	size:      sizeStringSlice,
-	marshal:   appendStringSliceValidateUTF8,
-	unmarshal: consumeStringSliceValidateUTF8,
-	merge:     mergeStringSlice,
-}
-
-// sizeStringValue returns the size of wire encoding a string value as a String.
-func sizeStringValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeBytes(len(v.String()))
-}
-
-// appendStringValue encodes a string value as a String.
-func appendStringValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendString(b, v.String())
-	return b, nil
-}
-
-// consumeStringValue decodes a string value as a String.
-func consumeStringValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeString(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfString(string(v)), out, nil
-}
-
-var coderStringValue = valueCoderFuncs{
-	size:      sizeStringValue,
-	marshal:   appendStringValue,
-	unmarshal: consumeStringValue,
-	merge:     mergeScalarValue,
-}
-
-// appendStringValueValidateUTF8 encodes a string value as a String.
-func appendStringValueValidateUTF8(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendString(b, v.String())
-	if !utf8.ValidString(v.String()) {
-		return b, errInvalidUTF8{}
-	}
-	return b, nil
-}
-
-// consumeStringValueValidateUTF8 decodes a string value as a String.
-func consumeStringValueValidateUTF8(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeString(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	if !utf8.ValidString(v) {
-		return protoreflect.Value{}, out, errInvalidUTF8{}
-	}
-	out.n = n
-	return protoreflect.ValueOfString(string(v)), out, nil
-}
-
-var coderStringValueValidateUTF8 = valueCoderFuncs{
-	size:      sizeStringValue,
-	marshal:   appendStringValueValidateUTF8,
-	unmarshal: consumeStringValueValidateUTF8,
-	merge:     mergeScalarValue,
-}
-
-// sizeStringSliceValue returns the size of wire encoding a []string value as a repeated String.
-func sizeStringSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		size += tagsize + protowire.SizeBytes(len(v.String()))
-	}
-	return size
-}
-
-// appendStringSliceValue encodes a []string value as a repeated String.
-func appendStringSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendString(b, v.String())
-	}
-	return b, nil
-}
-
-// consumeStringSliceValue wire decodes a []string value as a repeated String.
-func consumeStringSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp != protowire.BytesType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeString(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfString(string(v)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderStringSliceValue = valueCoderFuncs{
-	size:      sizeStringSliceValue,
-	marshal:   appendStringSliceValue,
-	unmarshal: consumeStringSliceValue,
-	merge:     mergeListValue,
-}
-
-// sizeBytes returns the size of wire encoding a []byte pointer as a Bytes.
-func sizeBytes(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Bytes()
-	return f.tagsize + protowire.SizeBytes(len(v))
-}
-
-// appendBytes wire encodes a []byte pointer as a Bytes.
-func appendBytes(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Bytes()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendBytes(b, v)
-	return b, nil
-}
-
-// consumeBytes wire decodes a []byte pointer as a Bytes.
-func consumeBytes(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Bytes() = append(emptyBuf[:], v...)
-	out.n = n
-	return out, nil
-}
-
-var coderBytes = pointerCoderFuncs{
-	size:      sizeBytes,
-	marshal:   appendBytes,
-	unmarshal: consumeBytes,
-	merge:     mergeBytes,
-}
-
-// appendBytesValidateUTF8 wire encodes a []byte pointer as a Bytes.
-func appendBytesValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Bytes()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendBytes(b, v)
-	if !utf8.Valid(v) {
-		return b, errInvalidUTF8{}
-	}
-	return b, nil
-}
-
-// consumeBytesValidateUTF8 wire decodes a []byte pointer as a Bytes.
-func consumeBytesValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	if !utf8.Valid(v) {
-		return out, errInvalidUTF8{}
-	}
-	*p.Bytes() = append(emptyBuf[:], v...)
-	out.n = n
-	return out, nil
-}
-
-var coderBytesValidateUTF8 = pointerCoderFuncs{
-	size:      sizeBytes,
-	marshal:   appendBytesValidateUTF8,
-	unmarshal: consumeBytesValidateUTF8,
-	merge:     mergeBytes,
-}
-
-// sizeBytesNoZero returns the size of wire encoding a []byte pointer as a Bytes.
-// The zero value is not encoded.
-func sizeBytesNoZero(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := *p.Bytes()
-	if len(v) == 0 {
-		return 0
-	}
-	return f.tagsize + protowire.SizeBytes(len(v))
-}
-
-// appendBytesNoZero wire encodes a []byte pointer as a Bytes.
-// The zero value is not encoded.
-func appendBytesNoZero(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Bytes()
-	if len(v) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendBytes(b, v)
-	return b, nil
-}
-
-// consumeBytesNoZero wire decodes a []byte pointer as a Bytes.
-// The zero value is not decoded.
-func consumeBytesNoZero(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*p.Bytes() = append(([]byte)(nil), v...)
-	out.n = n
-	return out, nil
-}
-
-var coderBytesNoZero = pointerCoderFuncs{
-	size:      sizeBytesNoZero,
-	marshal:   appendBytesNoZero,
-	unmarshal: consumeBytesNoZero,
-	merge:     mergeBytesNoZero,
-}
-
-// appendBytesNoZeroValidateUTF8 wire encodes a []byte pointer as a Bytes.
-// The zero value is not encoded.
-func appendBytesNoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	v := *p.Bytes()
-	if len(v) == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendBytes(b, v)
-	if !utf8.Valid(v) {
-		return b, errInvalidUTF8{}
-	}
-	return b, nil
-}
-
-// consumeBytesNoZeroValidateUTF8 wire decodes a []byte pointer as a Bytes.
-func consumeBytesNoZeroValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	if !utf8.Valid(v) {
-		return out, errInvalidUTF8{}
-	}
-	*p.Bytes() = append(([]byte)(nil), v...)
-	out.n = n
-	return out, nil
-}
-
-var coderBytesNoZeroValidateUTF8 = pointerCoderFuncs{
-	size:      sizeBytesNoZero,
-	marshal:   appendBytesNoZeroValidateUTF8,
-	unmarshal: consumeBytesNoZeroValidateUTF8,
-	merge:     mergeBytesNoZero,
-}
-
-// sizeBytesSlice returns the size of wire encoding a [][]byte pointer as a repeated Bytes.
-func sizeBytesSlice(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	s := *p.BytesSlice()
-	for _, v := range s {
-		size += f.tagsize + protowire.SizeBytes(len(v))
-	}
-	return size
-}
-
-// appendBytesSlice encodes a [][]byte pointer as a repeated Bytes.
-func appendBytesSlice(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.BytesSlice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendBytes(b, v)
-	}
-	return b, nil
-}
-
-// consumeBytesSlice wire decodes a [][]byte pointer as a repeated Bytes.
-func consumeBytesSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.BytesSlice()
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	*sp = append(*sp, append(emptyBuf[:], v...))
-	out.n = n
-	return out, nil
-}
-
-var coderBytesSlice = pointerCoderFuncs{
-	size:      sizeBytesSlice,
-	marshal:   appendBytesSlice,
-	unmarshal: consumeBytesSlice,
-	merge:     mergeBytesSlice,
-}
-
-// appendBytesSliceValidateUTF8 encodes a [][]byte pointer as a repeated Bytes.
-func appendBytesSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, _ marshalOptions) ([]byte, error) {
-	s := *p.BytesSlice()
-	for _, v := range s {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendBytes(b, v)
-		if !utf8.Valid(v) {
-			return b, errInvalidUTF8{}
-		}
-	}
-	return b, nil
-}
-
-// consumeBytesSliceValidateUTF8 wire decodes a [][]byte pointer as a repeated Bytes.
-func consumeBytesSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	sp := p.BytesSlice()
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	if !utf8.Valid(v) {
-		return out, errInvalidUTF8{}
-	}
-	*sp = append(*sp, append(emptyBuf[:], v...))
-	out.n = n
-	return out, nil
-}
-
-var coderBytesSliceValidateUTF8 = pointerCoderFuncs{
-	size:      sizeBytesSlice,
-	marshal:   appendBytesSliceValidateUTF8,
-	unmarshal: consumeBytesSliceValidateUTF8,
-	merge:     mergeBytesSlice,
-}
-
-// sizeBytesValue returns the size of wire encoding a []byte value as a Bytes.
-func sizeBytesValue(v protoreflect.Value, tagsize int, _ marshalOptions) int {
-	return tagsize + protowire.SizeBytes(len(v.Bytes()))
-}
-
-// appendBytesValue encodes a []byte value as a Bytes.
-func appendBytesValue(b []byte, v protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	b = protowire.AppendVarint(b, wiretag)
-	b = protowire.AppendBytes(b, v.Bytes())
-	return b, nil
-}
-
-// consumeBytesValue decodes a []byte value as a Bytes.
-func consumeBytesValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	out.n = n
-	return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), out, nil
-}
-
-var coderBytesValue = valueCoderFuncs{
-	size:      sizeBytesValue,
-	marshal:   appendBytesValue,
-	unmarshal: consumeBytesValue,
-	merge:     mergeBytesValue,
-}
-
-// sizeBytesSliceValue returns the size of wire encoding a [][]byte value as a repeated Bytes.
-func sizeBytesSliceValue(listv protoreflect.Value, tagsize int, _ marshalOptions) (size int) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		size += tagsize + protowire.SizeBytes(len(v.Bytes()))
-	}
-	return size
-}
-
-// appendBytesSliceValue encodes a [][]byte value as a repeated Bytes.
-func appendBytesSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, _ marshalOptions) ([]byte, error) {
-	list := listv.List()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		v := list.Get(i)
-		b = protowire.AppendVarint(b, wiretag)
-		b = protowire.AppendBytes(b, v.Bytes())
-	}
-	return b, nil
-}
-
-// consumeBytesSliceValue wire decodes a [][]byte value as a repeated Bytes.
-func consumeBytesSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, _ unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
-	list := listv.List()
-	if wtyp != protowire.BytesType {
-		return protoreflect.Value{}, out, errUnknown
-	}
-	v, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return protoreflect.Value{}, out, protowire.ParseError(n)
-	}
-	list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
-	out.n = n
-	return listv, out, nil
-}
-
-var coderBytesSliceValue = valueCoderFuncs{
-	size:      sizeBytesSliceValue,
-	marshal:   appendBytesSliceValue,
-	unmarshal: consumeBytesSliceValue,
-	merge:     mergeBytesListValue,
-}
-
-// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
-var emptyBuf [0]byte
-
-var wireTypes = map[protoreflect.Kind]protowire.Type{
-	protoreflect.BoolKind:     protowire.VarintType,
-	protoreflect.EnumKind:     protowire.VarintType,
-	protoreflect.Int32Kind:    protowire.VarintType,
-	protoreflect.Sint32Kind:   protowire.VarintType,
-	protoreflect.Uint32Kind:   protowire.VarintType,
-	protoreflect.Int64Kind:    protowire.VarintType,
-	protoreflect.Sint64Kind:   protowire.VarintType,
-	protoreflect.Uint64Kind:   protowire.VarintType,
-	protoreflect.Sfixed32Kind: protowire.Fixed32Type,
-	protoreflect.Fixed32Kind:  protowire.Fixed32Type,
-	protoreflect.FloatKind:    protowire.Fixed32Type,
-	protoreflect.Sfixed64Kind: protowire.Fixed64Type,
-	protoreflect.Fixed64Kind:  protowire.Fixed64Type,
-	protoreflect.DoubleKind:   protowire.Fixed64Type,
-	protoreflect.StringKind:   protowire.BytesType,
-	protoreflect.BytesKind:    protowire.BytesType,
-	protoreflect.MessageKind:  protowire.BytesType,
-	protoreflect.GroupKind:    protowire.StartGroupType,
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_map.go b/vendor/google.golang.org/protobuf/internal/impl/codec_map.go
deleted file mode 100644
index 35a67c2..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_map.go
+++ /dev/null
@@ -1,388 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"errors"
-	"reflect"
-	"sort"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type mapInfo struct {
-	goType     reflect.Type
-	keyWiretag uint64
-	valWiretag uint64
-	keyFuncs   valueCoderFuncs
-	valFuncs   valueCoderFuncs
-	keyZero    pref.Value
-	keyKind    pref.Kind
-	conv       *mapConverter
-}
-
-func encoderFuncsForMap(fd pref.FieldDescriptor, ft reflect.Type) (valueMessage *MessageInfo, funcs pointerCoderFuncs) {
-	// TODO: Consider generating specialized map coders.
-	keyField := fd.MapKey()
-	valField := fd.MapValue()
-	keyWiretag := protowire.EncodeTag(1, wireTypes[keyField.Kind()])
-	valWiretag := protowire.EncodeTag(2, wireTypes[valField.Kind()])
-	keyFuncs := encoderFuncsForValue(keyField)
-	valFuncs := encoderFuncsForValue(valField)
-	conv := newMapConverter(ft, fd)
-
-	mapi := &mapInfo{
-		goType:     ft,
-		keyWiretag: keyWiretag,
-		valWiretag: valWiretag,
-		keyFuncs:   keyFuncs,
-		valFuncs:   valFuncs,
-		keyZero:    keyField.Default(),
-		keyKind:    keyField.Kind(),
-		conv:       conv,
-	}
-	if valField.Kind() == pref.MessageKind {
-		valueMessage = getMessageInfo(ft.Elem())
-	}
-
-	funcs = pointerCoderFuncs{
-		size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
-			return sizeMap(p.AsValueOf(ft).Elem(), mapi, f, opts)
-		},
-		marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-			return appendMap(b, p.AsValueOf(ft).Elem(), mapi, f, opts)
-		},
-		unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
-			mp := p.AsValueOf(ft)
-			if mp.Elem().IsNil() {
-				mp.Elem().Set(reflect.MakeMap(mapi.goType))
-			}
-			if f.mi == nil {
-				return consumeMap(b, mp.Elem(), wtyp, mapi, f, opts)
-			} else {
-				return consumeMapOfMessage(b, mp.Elem(), wtyp, mapi, f, opts)
-			}
-		},
-	}
-	switch valField.Kind() {
-	case pref.MessageKind:
-		funcs.merge = mergeMapOfMessage
-	case pref.BytesKind:
-		funcs.merge = mergeMapOfBytes
-	default:
-		funcs.merge = mergeMap
-	}
-	if valFuncs.isInit != nil {
-		funcs.isInit = func(p pointer, f *coderFieldInfo) error {
-			return isInitMap(p.AsValueOf(ft).Elem(), mapi, f)
-		}
-	}
-	return valueMessage, funcs
-}
-
-const (
-	mapKeyTagSize = 1 // field 1, tag size 1.
-	mapValTagSize = 1 // field 2, tag size 2.
-)
-
-func sizeMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) int {
-	if mapv.Len() == 0 {
-		return 0
-	}
-	n := 0
-	iter := mapRange(mapv)
-	for iter.Next() {
-		key := mapi.conv.keyConv.PBValueOf(iter.Key()).MapKey()
-		keySize := mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
-		var valSize int
-		value := mapi.conv.valConv.PBValueOf(iter.Value())
-		if f.mi == nil {
-			valSize = mapi.valFuncs.size(value, mapValTagSize, opts)
-		} else {
-			p := pointerOfValue(iter.Value())
-			valSize += mapValTagSize
-			valSize += protowire.SizeBytes(f.mi.sizePointer(p, opts))
-		}
-		n += f.tagsize + protowire.SizeBytes(keySize+valSize)
-	}
-	return n
-}
-
-func consumeMap(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	b, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	var (
-		key = mapi.keyZero
-		val = mapi.conv.valConv.New()
-	)
-	for len(b) > 0 {
-		num, wtyp, n := protowire.ConsumeTag(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		if num > protowire.MaxValidNumber {
-			return out, errors.New("invalid field number")
-		}
-		b = b[n:]
-		err := errUnknown
-		switch num {
-		case 1:
-			var v pref.Value
-			var o unmarshalOutput
-			v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts)
-			if err != nil {
-				break
-			}
-			key = v
-			n = o.n
-		case 2:
-			var v pref.Value
-			var o unmarshalOutput
-			v, o, err = mapi.valFuncs.unmarshal(b, val, num, wtyp, opts)
-			if err != nil {
-				break
-			}
-			val = v
-			n = o.n
-		}
-		if err == errUnknown {
-			n = protowire.ConsumeFieldValue(num, wtyp, b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-		} else if err != nil {
-			return out, err
-		}
-		b = b[n:]
-	}
-	mapv.SetMapIndex(mapi.conv.keyConv.GoValueOf(key), mapi.conv.valConv.GoValueOf(val))
-	out.n = n
-	return out, nil
-}
-
-func consumeMapOfMessage(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.BytesType {
-		return out, errUnknown
-	}
-	b, n := protowire.ConsumeBytes(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	var (
-		key = mapi.keyZero
-		val = reflect.New(f.mi.GoReflectType.Elem())
-	)
-	for len(b) > 0 {
-		num, wtyp, n := protowire.ConsumeTag(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		if num > protowire.MaxValidNumber {
-			return out, errors.New("invalid field number")
-		}
-		b = b[n:]
-		err := errUnknown
-		switch num {
-		case 1:
-			var v pref.Value
-			var o unmarshalOutput
-			v, o, err = mapi.keyFuncs.unmarshal(b, key, num, wtyp, opts)
-			if err != nil {
-				break
-			}
-			key = v
-			n = o.n
-		case 2:
-			if wtyp != protowire.BytesType {
-				break
-			}
-			var v []byte
-			v, n = protowire.ConsumeBytes(b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			var o unmarshalOutput
-			o, err = f.mi.unmarshalPointer(v, pointerOfValue(val), 0, opts)
-			if o.initialized {
-				// Consider this map item initialized so long as we see
-				// an initialized value.
-				out.initialized = true
-			}
-		}
-		if err == errUnknown {
-			n = protowire.ConsumeFieldValue(num, wtyp, b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-		} else if err != nil {
-			return out, err
-		}
-		b = b[n:]
-	}
-	mapv.SetMapIndex(mapi.conv.keyConv.GoValueOf(key), val)
-	out.n = n
-	return out, nil
-}
-
-func appendMapItem(b []byte, keyrv, valrv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	if f.mi == nil {
-		key := mapi.conv.keyConv.PBValueOf(keyrv).MapKey()
-		val := mapi.conv.valConv.PBValueOf(valrv)
-		size := 0
-		size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
-		size += mapi.valFuncs.size(val, mapValTagSize, opts)
-		b = protowire.AppendVarint(b, uint64(size))
-		b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts)
-		if err != nil {
-			return nil, err
-		}
-		return mapi.valFuncs.marshal(b, val, mapi.valWiretag, opts)
-	} else {
-		key := mapi.conv.keyConv.PBValueOf(keyrv).MapKey()
-		val := pointerOfValue(valrv)
-		valSize := f.mi.sizePointer(val, opts)
-		size := 0
-		size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts)
-		size += mapValTagSize + protowire.SizeBytes(valSize)
-		b = protowire.AppendVarint(b, uint64(size))
-		b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts)
-		if err != nil {
-			return nil, err
-		}
-		b = protowire.AppendVarint(b, mapi.valWiretag)
-		b = protowire.AppendVarint(b, uint64(valSize))
-		return f.mi.marshalAppendPointer(b, val, opts)
-	}
-}
-
-func appendMap(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	if mapv.Len() == 0 {
-		return b, nil
-	}
-	if opts.Deterministic() {
-		return appendMapDeterministic(b, mapv, mapi, f, opts)
-	}
-	iter := mapRange(mapv)
-	for iter.Next() {
-		var err error
-		b = protowire.AppendVarint(b, f.wiretag)
-		b, err = appendMapItem(b, iter.Key(), iter.Value(), mapi, f, opts)
-		if err != nil {
-			return b, err
-		}
-	}
-	return b, nil
-}
-
-func appendMapDeterministic(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	keys := mapv.MapKeys()
-	sort.Slice(keys, func(i, j int) bool {
-		switch keys[i].Kind() {
-		case reflect.Bool:
-			return !keys[i].Bool() && keys[j].Bool()
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			return keys[i].Int() < keys[j].Int()
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-			return keys[i].Uint() < keys[j].Uint()
-		case reflect.Float32, reflect.Float64:
-			return keys[i].Float() < keys[j].Float()
-		case reflect.String:
-			return keys[i].String() < keys[j].String()
-		default:
-			panic("invalid kind: " + keys[i].Kind().String())
-		}
-	})
-	for _, key := range keys {
-		var err error
-		b = protowire.AppendVarint(b, f.wiretag)
-		b, err = appendMapItem(b, key, mapv.MapIndex(key), mapi, f, opts)
-		if err != nil {
-			return b, err
-		}
-	}
-	return b, nil
-}
-
-func isInitMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo) error {
-	if mi := f.mi; mi != nil {
-		mi.init()
-		if !mi.needsInitCheck {
-			return nil
-		}
-		iter := mapRange(mapv)
-		for iter.Next() {
-			val := pointerOfValue(iter.Value())
-			if err := mi.checkInitializedPointer(val); err != nil {
-				return err
-			}
-		}
-	} else {
-		iter := mapRange(mapv)
-		for iter.Next() {
-			val := mapi.conv.valConv.PBValueOf(iter.Value())
-			if err := mapi.valFuncs.isInit(val); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func mergeMap(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
-	dstm := dst.AsValueOf(f.ft).Elem()
-	srcm := src.AsValueOf(f.ft).Elem()
-	if srcm.Len() == 0 {
-		return
-	}
-	if dstm.IsNil() {
-		dstm.Set(reflect.MakeMap(f.ft))
-	}
-	iter := mapRange(srcm)
-	for iter.Next() {
-		dstm.SetMapIndex(iter.Key(), iter.Value())
-	}
-}
-
-func mergeMapOfBytes(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
-	dstm := dst.AsValueOf(f.ft).Elem()
-	srcm := src.AsValueOf(f.ft).Elem()
-	if srcm.Len() == 0 {
-		return
-	}
-	if dstm.IsNil() {
-		dstm.Set(reflect.MakeMap(f.ft))
-	}
-	iter := mapRange(srcm)
-	for iter.Next() {
-		dstm.SetMapIndex(iter.Key(), reflect.ValueOf(append(emptyBuf[:], iter.Value().Bytes()...)))
-	}
-}
-
-func mergeMapOfMessage(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
-	dstm := dst.AsValueOf(f.ft).Elem()
-	srcm := src.AsValueOf(f.ft).Elem()
-	if srcm.Len() == 0 {
-		return
-	}
-	if dstm.IsNil() {
-		dstm.Set(reflect.MakeMap(f.ft))
-	}
-	iter := mapRange(srcm)
-	for iter.Next() {
-		val := reflect.New(f.ft.Elem().Elem())
-		if f.mi != nil {
-			f.mi.mergePointer(pointerOfValue(val), pointerOfValue(iter.Value()), opts)
-		} else {
-			opts.Merge(asMessage(val), asMessage(iter.Value()))
-		}
-		dstm.SetMapIndex(iter.Key(), val)
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go b/vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go
deleted file mode 100644
index 2706bb6..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !go1.12
-
-package impl
-
-import "reflect"
-
-type mapIter struct {
-	v    reflect.Value
-	keys []reflect.Value
-}
-
-// mapRange provides a less-efficient equivalent to
-// the Go 1.12 reflect.Value.MapRange method.
-func mapRange(v reflect.Value) *mapIter {
-	return &mapIter{v: v}
-}
-
-func (i *mapIter) Next() bool {
-	if i.keys == nil {
-		i.keys = i.v.MapKeys()
-	} else {
-		i.keys = i.keys[1:]
-	}
-	return len(i.keys) > 0
-}
-
-func (i *mapIter) Key() reflect.Value {
-	return i.keys[0]
-}
-
-func (i *mapIter) Value() reflect.Value {
-	return i.v.MapIndex(i.keys[0])
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go b/vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go
deleted file mode 100644
index 1533ef6..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.12
-
-package impl
-
-import "reflect"
-
-func mapRange(v reflect.Value) *reflect.MapIter { return v.MapRange() }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_message.go b/vendor/google.golang.org/protobuf/internal/impl/codec_message.go
deleted file mode 100644
index 0e176d5..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_message.go
+++ /dev/null
@@ -1,159 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-	"sort"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/fieldsort"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// coderMessageInfo contains per-message information used by the fast-path functions.
-// This is a different type from MessageInfo to keep MessageInfo as general-purpose as
-// possible.
-type coderMessageInfo struct {
-	methods piface.Methods
-
-	orderedCoderFields []*coderFieldInfo
-	denseCoderFields   []*coderFieldInfo
-	coderFields        map[protowire.Number]*coderFieldInfo
-	sizecacheOffset    offset
-	unknownOffset      offset
-	extensionOffset    offset
-	needsInitCheck     bool
-	isMessageSet       bool
-	numRequiredFields  uint8
-}
-
-type coderFieldInfo struct {
-	funcs      pointerCoderFuncs // fast-path per-field functions
-	mi         *MessageInfo      // field's message
-	ft         reflect.Type
-	validation validationInfo   // information used by message validation
-	num        pref.FieldNumber // field number
-	offset     offset           // struct field offset
-	wiretag    uint64           // field tag (number + wire type)
-	tagsize    int              // size of the varint-encoded tag
-	isPointer  bool             // true if IsNil may be called on the struct field
-	isRequired bool             // true if field is required
-}
-
-func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
-	mi.sizecacheOffset = si.sizecacheOffset
-	mi.unknownOffset = si.unknownOffset
-	mi.extensionOffset = si.extensionOffset
-
-	mi.coderFields = make(map[protowire.Number]*coderFieldInfo)
-	fields := mi.Desc.Fields()
-	preallocFields := make([]coderFieldInfo, fields.Len())
-	for i := 0; i < fields.Len(); i++ {
-		fd := fields.Get(i)
-
-		fs := si.fieldsByNumber[fd.Number()]
-		isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()
-		if isOneof {
-			fs = si.oneofsByName[fd.ContainingOneof().Name()]
-		}
-		ft := fs.Type
-		var wiretag uint64
-		if !fd.IsPacked() {
-			wiretag = protowire.EncodeTag(fd.Number(), wireTypes[fd.Kind()])
-		} else {
-			wiretag = protowire.EncodeTag(fd.Number(), protowire.BytesType)
-		}
-		var fieldOffset offset
-		var funcs pointerCoderFuncs
-		var childMessage *MessageInfo
-		switch {
-		case isOneof:
-			fieldOffset = offsetOf(fs, mi.Exporter)
-		case fd.IsWeak():
-			fieldOffset = si.weakOffset
-			funcs = makeWeakMessageFieldCoder(fd)
-		default:
-			fieldOffset = offsetOf(fs, mi.Exporter)
-			childMessage, funcs = fieldCoder(fd, ft)
-		}
-		cf := &preallocFields[i]
-		*cf = coderFieldInfo{
-			num:        fd.Number(),
-			offset:     fieldOffset,
-			wiretag:    wiretag,
-			ft:         ft,
-			tagsize:    protowire.SizeVarint(wiretag),
-			funcs:      funcs,
-			mi:         childMessage,
-			validation: newFieldValidationInfo(mi, si, fd, ft),
-			isPointer:  fd.Cardinality() == pref.Repeated || fd.HasPresence(),
-			isRequired: fd.Cardinality() == pref.Required,
-		}
-		mi.orderedCoderFields = append(mi.orderedCoderFields, cf)
-		mi.coderFields[cf.num] = cf
-	}
-	for i, oneofs := 0, mi.Desc.Oneofs(); i < oneofs.Len(); i++ {
-		if od := oneofs.Get(i); !od.IsSynthetic() {
-			mi.initOneofFieldCoders(od, si)
-		}
-	}
-	if messageset.IsMessageSet(mi.Desc) {
-		if !mi.extensionOffset.IsValid() {
-			panic(fmt.Sprintf("%v: MessageSet with no extensions field", mi.Desc.FullName()))
-		}
-		if !mi.unknownOffset.IsValid() {
-			panic(fmt.Sprintf("%v: MessageSet with no unknown field", mi.Desc.FullName()))
-		}
-		mi.isMessageSet = true
-	}
-	sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
-		return mi.orderedCoderFields[i].num < mi.orderedCoderFields[j].num
-	})
-
-	var maxDense pref.FieldNumber
-	for _, cf := range mi.orderedCoderFields {
-		if cf.num >= 16 && cf.num >= 2*maxDense {
-			break
-		}
-		maxDense = cf.num
-	}
-	mi.denseCoderFields = make([]*coderFieldInfo, maxDense+1)
-	for _, cf := range mi.orderedCoderFields {
-		if int(cf.num) >= len(mi.denseCoderFields) {
-			break
-		}
-		mi.denseCoderFields[cf.num] = cf
-	}
-
-	// To preserve compatibility with historic wire output, marshal oneofs last.
-	if mi.Desc.Oneofs().Len() > 0 {
-		sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
-			fi := fields.ByNumber(mi.orderedCoderFields[i].num)
-			fj := fields.ByNumber(mi.orderedCoderFields[j].num)
-			return fieldsort.Less(fi, fj)
-		})
-	}
-
-	mi.needsInitCheck = needsInitCheck(mi.Desc)
-	if mi.methods.Marshal == nil && mi.methods.Size == nil {
-		mi.methods.Flags |= piface.SupportMarshalDeterministic
-		mi.methods.Marshal = mi.marshal
-		mi.methods.Size = mi.size
-	}
-	if mi.methods.Unmarshal == nil {
-		mi.methods.Flags |= piface.SupportUnmarshalDiscardUnknown
-		mi.methods.Unmarshal = mi.unmarshal
-	}
-	if mi.methods.CheckInitialized == nil {
-		mi.methods.CheckInitialized = mi.checkInitialized
-	}
-	if mi.methods.Merge == nil {
-		mi.methods.Merge = mi.merge
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go b/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go
deleted file mode 100644
index cfb68e1..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"sort"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/flags"
-)
-
-func sizeMessageSet(mi *MessageInfo, p pointer, opts marshalOptions) (size int) {
-	if !flags.ProtoLegacy {
-		return 0
-	}
-
-	ext := *p.Apply(mi.extensionOffset).Extensions()
-	for _, x := range ext {
-		xi := getExtensionFieldInfo(x.Type())
-		if xi.funcs.size == nil {
-			continue
-		}
-		num, _ := protowire.DecodeTag(xi.wiretag)
-		size += messageset.SizeField(num)
-		size += xi.funcs.size(x.Value(), protowire.SizeTag(messageset.FieldMessage), opts)
-	}
-
-	unknown := *p.Apply(mi.unknownOffset).Bytes()
-	size += messageset.SizeUnknown(unknown)
-
-	return size
-}
-
-func marshalMessageSet(mi *MessageInfo, b []byte, p pointer, opts marshalOptions) ([]byte, error) {
-	if !flags.ProtoLegacy {
-		return b, errors.New("no support for message_set_wire_format")
-	}
-
-	ext := *p.Apply(mi.extensionOffset).Extensions()
-	switch len(ext) {
-	case 0:
-	case 1:
-		// Fast-path for one extension: Don't bother sorting the keys.
-		for _, x := range ext {
-			var err error
-			b, err = marshalMessageSetField(mi, b, x, opts)
-			if err != nil {
-				return b, err
-			}
-		}
-	default:
-		// Sort the keys to provide a deterministic encoding.
-		// Not sure this is required, but the old code does it.
-		keys := make([]int, 0, len(ext))
-		for k := range ext {
-			keys = append(keys, int(k))
-		}
-		sort.Ints(keys)
-		for _, k := range keys {
-			var err error
-			b, err = marshalMessageSetField(mi, b, ext[int32(k)], opts)
-			if err != nil {
-				return b, err
-			}
-		}
-	}
-
-	unknown := *p.Apply(mi.unknownOffset).Bytes()
-	b, err := messageset.AppendUnknown(b, unknown)
-	if err != nil {
-		return b, err
-	}
-
-	return b, nil
-}
-
-func marshalMessageSetField(mi *MessageInfo, b []byte, x ExtensionField, opts marshalOptions) ([]byte, error) {
-	xi := getExtensionFieldInfo(x.Type())
-	num, _ := protowire.DecodeTag(xi.wiretag)
-	b = messageset.AppendFieldStart(b, num)
-	b, err := xi.funcs.marshal(b, x.Value(), protowire.EncodeTag(messageset.FieldMessage, protowire.BytesType), opts)
-	if err != nil {
-		return b, err
-	}
-	b = messageset.AppendFieldEnd(b)
-	return b, nil
-}
-
-func unmarshalMessageSet(mi *MessageInfo, b []byte, p pointer, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if !flags.ProtoLegacy {
-		return out, errors.New("no support for message_set_wire_format")
-	}
-
-	ep := p.Apply(mi.extensionOffset).Extensions()
-	if *ep == nil {
-		*ep = make(map[int32]ExtensionField)
-	}
-	ext := *ep
-	unknown := p.Apply(mi.unknownOffset).Bytes()
-	initialized := true
-	err = messageset.Unmarshal(b, true, func(num protowire.Number, v []byte) error {
-		o, err := mi.unmarshalExtension(v, num, protowire.BytesType, ext, opts)
-		if err == errUnknown {
-			*unknown = protowire.AppendTag(*unknown, num, protowire.BytesType)
-			*unknown = append(*unknown, v...)
-			return nil
-		}
-		if !o.initialized {
-			initialized = false
-		}
-		return err
-	})
-	out.n = len(b)
-	out.initialized = initialized
-	return out, err
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go
deleted file mode 100644
index 86f7dc3..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_reflect.go
+++ /dev/null
@@ -1,209 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build purego appengine
-
-package impl
-
-import (
-	"reflect"
-
-	"google.golang.org/protobuf/encoding/protowire"
-)
-
-func sizeEnum(p pointer, f *coderFieldInfo, _ marshalOptions) (size int) {
-	v := p.v.Elem().Int()
-	return f.tagsize + protowire.SizeVarint(uint64(v))
-}
-
-func appendEnum(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	v := p.v.Elem().Int()
-	b = protowire.AppendVarint(b, f.wiretag)
-	b = protowire.AppendVarint(b, uint64(v))
-	return b, nil
-}
-
-func consumeEnum(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, _ unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeVarint(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	p.v.Elem().SetInt(int64(v))
-	out.n = n
-	return out, nil
-}
-
-func mergeEnum(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	dst.v.Elem().Set(src.v.Elem())
-}
-
-var coderEnum = pointerCoderFuncs{
-	size:      sizeEnum,
-	marshal:   appendEnum,
-	unmarshal: consumeEnum,
-	merge:     mergeEnum,
-}
-
-func sizeEnumNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
-	if p.v.Elem().Int() == 0 {
-		return 0
-	}
-	return sizeEnum(p, f, opts)
-}
-
-func appendEnumNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	if p.v.Elem().Int() == 0 {
-		return b, nil
-	}
-	return appendEnum(b, p, f, opts)
-}
-
-func mergeEnumNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	if src.v.Elem().Int() != 0 {
-		dst.v.Elem().Set(src.v.Elem())
-	}
-}
-
-var coderEnumNoZero = pointerCoderFuncs{
-	size:      sizeEnumNoZero,
-	marshal:   appendEnumNoZero,
-	unmarshal: consumeEnum,
-	merge:     mergeEnumNoZero,
-}
-
-func sizeEnumPtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
-	return sizeEnum(pointer{p.v.Elem()}, f, opts)
-}
-
-func appendEnumPtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	return appendEnum(b, pointer{p.v.Elem()}, f, opts)
-}
-
-func consumeEnumPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	if p.v.Elem().IsNil() {
-		p.v.Elem().Set(reflect.New(p.v.Elem().Type().Elem()))
-	}
-	return consumeEnum(b, pointer{p.v.Elem()}, wtyp, f, opts)
-}
-
-func mergeEnumPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	if !src.v.Elem().IsNil() {
-		v := reflect.New(dst.v.Type().Elem().Elem())
-		v.Elem().Set(src.v.Elem().Elem())
-		dst.v.Elem().Set(v)
-	}
-}
-
-var coderEnumPtr = pointerCoderFuncs{
-	size:      sizeEnumPtr,
-	marshal:   appendEnumPtr,
-	unmarshal: consumeEnumPtr,
-	merge:     mergeEnumPtr,
-}
-
-func sizeEnumSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
-	s := p.v.Elem()
-	for i, llen := 0, s.Len(); i < llen; i++ {
-		size += protowire.SizeVarint(uint64(s.Index(i).Int())) + f.tagsize
-	}
-	return size
-}
-
-func appendEnumSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	s := p.v.Elem()
-	for i, llen := 0, s.Len(); i < llen; i++ {
-		b = protowire.AppendVarint(b, f.wiretag)
-		b = protowire.AppendVarint(b, uint64(s.Index(i).Int()))
-	}
-	return b, nil
-}
-
-func consumeEnumSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	s := p.v.Elem()
-	if wtyp == protowire.BytesType {
-		b, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, protowire.ParseError(n)
-		}
-		for len(b) > 0 {
-			v, n := protowire.ConsumeVarint(b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			rv := reflect.New(s.Type().Elem()).Elem()
-			rv.SetInt(int64(v))
-			s.Set(reflect.Append(s, rv))
-			b = b[n:]
-		}
-		out.n = n
-		return out, nil
-	}
-	if wtyp != protowire.VarintType {
-		return out, errUnknown
-	}
-	v, n := protowire.ConsumeVarint(b)
-	if n < 0 {
-		return out, protowire.ParseError(n)
-	}
-	rv := reflect.New(s.Type().Elem()).Elem()
-	rv.SetInt(int64(v))
-	s.Set(reflect.Append(s, rv))
-	out.n = n
-	return out, nil
-}
-
-func mergeEnumSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	dst.v.Elem().Set(reflect.AppendSlice(dst.v.Elem(), src.v.Elem()))
-}
-
-var coderEnumSlice = pointerCoderFuncs{
-	size:      sizeEnumSlice,
-	marshal:   appendEnumSlice,
-	unmarshal: consumeEnumSlice,
-	merge:     mergeEnumSlice,
-}
-
-func sizeEnumPackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
-	s := p.v.Elem()
-	llen := s.Len()
-	if llen == 0 {
-		return 0
-	}
-	n := 0
-	for i := 0; i < llen; i++ {
-		n += protowire.SizeVarint(uint64(s.Index(i).Int()))
-	}
-	return f.tagsize + protowire.SizeBytes(n)
-}
-
-func appendEnumPackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
-	s := p.v.Elem()
-	llen := s.Len()
-	if llen == 0 {
-		return b, nil
-	}
-	b = protowire.AppendVarint(b, f.wiretag)
-	n := 0
-	for i := 0; i < llen; i++ {
-		n += protowire.SizeVarint(uint64(s.Index(i).Int()))
-	}
-	b = protowire.AppendVarint(b, uint64(n))
-	for i := 0; i < llen; i++ {
-		b = protowire.AppendVarint(b, uint64(s.Index(i).Int()))
-	}
-	return b, nil
-}
-
-var coderEnumPackedSlice = pointerCoderFuncs{
-	size:      sizeEnumPackedSlice,
-	marshal:   appendEnumPackedSlice,
-	unmarshal: consumeEnumSlice,
-	merge:     mergeEnumSlice,
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_tables.go b/vendor/google.golang.org/protobuf/internal/impl/codec_tables.go
deleted file mode 100644
index e899712..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_tables.go
+++ /dev/null
@@ -1,557 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/strs"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// pointerCoderFuncs is a set of pointer encoding functions.
-type pointerCoderFuncs struct {
-	mi        *MessageInfo
-	size      func(p pointer, f *coderFieldInfo, opts marshalOptions) int
-	marshal   func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error)
-	unmarshal func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error)
-	isInit    func(p pointer, f *coderFieldInfo) error
-	merge     func(dst, src pointer, f *coderFieldInfo, opts mergeOptions)
-}
-
-// valueCoderFuncs is a set of protoreflect.Value encoding functions.
-type valueCoderFuncs struct {
-	size      func(v pref.Value, tagsize int, opts marshalOptions) int
-	marshal   func(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error)
-	unmarshal func(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error)
-	isInit    func(v pref.Value) error
-	merge     func(dst, src pref.Value, opts mergeOptions) pref.Value
-}
-
-// fieldCoder returns pointer functions for a field, used for operating on
-// struct fields.
-func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
-	switch {
-	case fd.IsMap():
-		return encoderFuncsForMap(fd, ft)
-	case fd.Cardinality() == pref.Repeated && !fd.IsPacked():
-		// Repeated fields (not packed).
-		if ft.Kind() != reflect.Slice {
-			break
-		}
-		ft := ft.Elem()
-		switch fd.Kind() {
-		case pref.BoolKind:
-			if ft.Kind() == reflect.Bool {
-				return nil, coderBoolSlice
-			}
-		case pref.EnumKind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderEnumSlice
-			}
-		case pref.Int32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderInt32Slice
-			}
-		case pref.Sint32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderSint32Slice
-			}
-		case pref.Uint32Kind:
-			if ft.Kind() == reflect.Uint32 {
-				return nil, coderUint32Slice
-			}
-		case pref.Int64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderInt64Slice
-			}
-		case pref.Sint64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderSint64Slice
-			}
-		case pref.Uint64Kind:
-			if ft.Kind() == reflect.Uint64 {
-				return nil, coderUint64Slice
-			}
-		case pref.Sfixed32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderSfixed32Slice
-			}
-		case pref.Fixed32Kind:
-			if ft.Kind() == reflect.Uint32 {
-				return nil, coderFixed32Slice
-			}
-		case pref.FloatKind:
-			if ft.Kind() == reflect.Float32 {
-				return nil, coderFloatSlice
-			}
-		case pref.Sfixed64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderSfixed64Slice
-			}
-		case pref.Fixed64Kind:
-			if ft.Kind() == reflect.Uint64 {
-				return nil, coderFixed64Slice
-			}
-		case pref.DoubleKind:
-			if ft.Kind() == reflect.Float64 {
-				return nil, coderDoubleSlice
-			}
-		case pref.StringKind:
-			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
-				return nil, coderStringSliceValidateUTF8
-			}
-			if ft.Kind() == reflect.String {
-				return nil, coderStringSlice
-			}
-			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
-				return nil, coderBytesSliceValidateUTF8
-			}
-			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
-				return nil, coderBytesSlice
-			}
-		case pref.BytesKind:
-			if ft.Kind() == reflect.String {
-				return nil, coderStringSlice
-			}
-			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
-				return nil, coderBytesSlice
-			}
-		case pref.MessageKind:
-			return getMessageInfo(ft), makeMessageSliceFieldCoder(fd, ft)
-		case pref.GroupKind:
-			return getMessageInfo(ft), makeGroupSliceFieldCoder(fd, ft)
-		}
-	case fd.Cardinality() == pref.Repeated && fd.IsPacked():
-		// Packed repeated fields.
-		//
-		// Only repeated fields of primitive numeric types
-		// (Varint, Fixed32, or Fixed64 wire type) can be packed.
-		if ft.Kind() != reflect.Slice {
-			break
-		}
-		ft := ft.Elem()
-		switch fd.Kind() {
-		case pref.BoolKind:
-			if ft.Kind() == reflect.Bool {
-				return nil, coderBoolPackedSlice
-			}
-		case pref.EnumKind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderEnumPackedSlice
-			}
-		case pref.Int32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderInt32PackedSlice
-			}
-		case pref.Sint32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderSint32PackedSlice
-			}
-		case pref.Uint32Kind:
-			if ft.Kind() == reflect.Uint32 {
-				return nil, coderUint32PackedSlice
-			}
-		case pref.Int64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderInt64PackedSlice
-			}
-		case pref.Sint64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderSint64PackedSlice
-			}
-		case pref.Uint64Kind:
-			if ft.Kind() == reflect.Uint64 {
-				return nil, coderUint64PackedSlice
-			}
-		case pref.Sfixed32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderSfixed32PackedSlice
-			}
-		case pref.Fixed32Kind:
-			if ft.Kind() == reflect.Uint32 {
-				return nil, coderFixed32PackedSlice
-			}
-		case pref.FloatKind:
-			if ft.Kind() == reflect.Float32 {
-				return nil, coderFloatPackedSlice
-			}
-		case pref.Sfixed64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderSfixed64PackedSlice
-			}
-		case pref.Fixed64Kind:
-			if ft.Kind() == reflect.Uint64 {
-				return nil, coderFixed64PackedSlice
-			}
-		case pref.DoubleKind:
-			if ft.Kind() == reflect.Float64 {
-				return nil, coderDoublePackedSlice
-			}
-		}
-	case fd.Kind() == pref.MessageKind:
-		return getMessageInfo(ft), makeMessageFieldCoder(fd, ft)
-	case fd.Kind() == pref.GroupKind:
-		return getMessageInfo(ft), makeGroupFieldCoder(fd, ft)
-	case fd.Syntax() == pref.Proto3 && fd.ContainingOneof() == nil:
-		// Populated oneof fields always encode even if set to the zero value,
-		// which normally are not encoded in proto3.
-		switch fd.Kind() {
-		case pref.BoolKind:
-			if ft.Kind() == reflect.Bool {
-				return nil, coderBoolNoZero
-			}
-		case pref.EnumKind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderEnumNoZero
-			}
-		case pref.Int32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderInt32NoZero
-			}
-		case pref.Sint32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderSint32NoZero
-			}
-		case pref.Uint32Kind:
-			if ft.Kind() == reflect.Uint32 {
-				return nil, coderUint32NoZero
-			}
-		case pref.Int64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderInt64NoZero
-			}
-		case pref.Sint64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderSint64NoZero
-			}
-		case pref.Uint64Kind:
-			if ft.Kind() == reflect.Uint64 {
-				return nil, coderUint64NoZero
-			}
-		case pref.Sfixed32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderSfixed32NoZero
-			}
-		case pref.Fixed32Kind:
-			if ft.Kind() == reflect.Uint32 {
-				return nil, coderFixed32NoZero
-			}
-		case pref.FloatKind:
-			if ft.Kind() == reflect.Float32 {
-				return nil, coderFloatNoZero
-			}
-		case pref.Sfixed64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderSfixed64NoZero
-			}
-		case pref.Fixed64Kind:
-			if ft.Kind() == reflect.Uint64 {
-				return nil, coderFixed64NoZero
-			}
-		case pref.DoubleKind:
-			if ft.Kind() == reflect.Float64 {
-				return nil, coderDoubleNoZero
-			}
-		case pref.StringKind:
-			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
-				return nil, coderStringNoZeroValidateUTF8
-			}
-			if ft.Kind() == reflect.String {
-				return nil, coderStringNoZero
-			}
-			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
-				return nil, coderBytesNoZeroValidateUTF8
-			}
-			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
-				return nil, coderBytesNoZero
-			}
-		case pref.BytesKind:
-			if ft.Kind() == reflect.String {
-				return nil, coderStringNoZero
-			}
-			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
-				return nil, coderBytesNoZero
-			}
-		}
-	case ft.Kind() == reflect.Ptr:
-		ft := ft.Elem()
-		switch fd.Kind() {
-		case pref.BoolKind:
-			if ft.Kind() == reflect.Bool {
-				return nil, coderBoolPtr
-			}
-		case pref.EnumKind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderEnumPtr
-			}
-		case pref.Int32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderInt32Ptr
-			}
-		case pref.Sint32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderSint32Ptr
-			}
-		case pref.Uint32Kind:
-			if ft.Kind() == reflect.Uint32 {
-				return nil, coderUint32Ptr
-			}
-		case pref.Int64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderInt64Ptr
-			}
-		case pref.Sint64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderSint64Ptr
-			}
-		case pref.Uint64Kind:
-			if ft.Kind() == reflect.Uint64 {
-				return nil, coderUint64Ptr
-			}
-		case pref.Sfixed32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderSfixed32Ptr
-			}
-		case pref.Fixed32Kind:
-			if ft.Kind() == reflect.Uint32 {
-				return nil, coderFixed32Ptr
-			}
-		case pref.FloatKind:
-			if ft.Kind() == reflect.Float32 {
-				return nil, coderFloatPtr
-			}
-		case pref.Sfixed64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderSfixed64Ptr
-			}
-		case pref.Fixed64Kind:
-			if ft.Kind() == reflect.Uint64 {
-				return nil, coderFixed64Ptr
-			}
-		case pref.DoubleKind:
-			if ft.Kind() == reflect.Float64 {
-				return nil, coderDoublePtr
-			}
-		case pref.StringKind:
-			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
-				return nil, coderStringPtrValidateUTF8
-			}
-			if ft.Kind() == reflect.String {
-				return nil, coderStringPtr
-			}
-		case pref.BytesKind:
-			if ft.Kind() == reflect.String {
-				return nil, coderStringPtr
-			}
-		}
-	default:
-		switch fd.Kind() {
-		case pref.BoolKind:
-			if ft.Kind() == reflect.Bool {
-				return nil, coderBool
-			}
-		case pref.EnumKind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderEnum
-			}
-		case pref.Int32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderInt32
-			}
-		case pref.Sint32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderSint32
-			}
-		case pref.Uint32Kind:
-			if ft.Kind() == reflect.Uint32 {
-				return nil, coderUint32
-			}
-		case pref.Int64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderInt64
-			}
-		case pref.Sint64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderSint64
-			}
-		case pref.Uint64Kind:
-			if ft.Kind() == reflect.Uint64 {
-				return nil, coderUint64
-			}
-		case pref.Sfixed32Kind:
-			if ft.Kind() == reflect.Int32 {
-				return nil, coderSfixed32
-			}
-		case pref.Fixed32Kind:
-			if ft.Kind() == reflect.Uint32 {
-				return nil, coderFixed32
-			}
-		case pref.FloatKind:
-			if ft.Kind() == reflect.Float32 {
-				return nil, coderFloat
-			}
-		case pref.Sfixed64Kind:
-			if ft.Kind() == reflect.Int64 {
-				return nil, coderSfixed64
-			}
-		case pref.Fixed64Kind:
-			if ft.Kind() == reflect.Uint64 {
-				return nil, coderFixed64
-			}
-		case pref.DoubleKind:
-			if ft.Kind() == reflect.Float64 {
-				return nil, coderDouble
-			}
-		case pref.StringKind:
-			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
-				return nil, coderStringValidateUTF8
-			}
-			if ft.Kind() == reflect.String {
-				return nil, coderString
-			}
-			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
-				return nil, coderBytesValidateUTF8
-			}
-			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
-				return nil, coderBytes
-			}
-		case pref.BytesKind:
-			if ft.Kind() == reflect.String {
-				return nil, coderString
-			}
-			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
-				return nil, coderBytes
-			}
-		}
-	}
-	panic(fmt.Sprintf("invalid type: no encoder for %v %v %v/%v", fd.FullName(), fd.Cardinality(), fd.Kind(), ft))
-}
-
-// encoderFuncsForValue returns value functions for a field, used for
-// extension values and map encoding.
-func encoderFuncsForValue(fd pref.FieldDescriptor) valueCoderFuncs {
-	switch {
-	case fd.Cardinality() == pref.Repeated && !fd.IsPacked():
-		switch fd.Kind() {
-		case pref.BoolKind:
-			return coderBoolSliceValue
-		case pref.EnumKind:
-			return coderEnumSliceValue
-		case pref.Int32Kind:
-			return coderInt32SliceValue
-		case pref.Sint32Kind:
-			return coderSint32SliceValue
-		case pref.Uint32Kind:
-			return coderUint32SliceValue
-		case pref.Int64Kind:
-			return coderInt64SliceValue
-		case pref.Sint64Kind:
-			return coderSint64SliceValue
-		case pref.Uint64Kind:
-			return coderUint64SliceValue
-		case pref.Sfixed32Kind:
-			return coderSfixed32SliceValue
-		case pref.Fixed32Kind:
-			return coderFixed32SliceValue
-		case pref.FloatKind:
-			return coderFloatSliceValue
-		case pref.Sfixed64Kind:
-			return coderSfixed64SliceValue
-		case pref.Fixed64Kind:
-			return coderFixed64SliceValue
-		case pref.DoubleKind:
-			return coderDoubleSliceValue
-		case pref.StringKind:
-			// We don't have a UTF-8 validating coder for repeated string fields.
-			// Value coders are used for extensions and maps.
-			// Extensions are never proto3, and maps never contain lists.
-			return coderStringSliceValue
-		case pref.BytesKind:
-			return coderBytesSliceValue
-		case pref.MessageKind:
-			return coderMessageSliceValue
-		case pref.GroupKind:
-			return coderGroupSliceValue
-		}
-	case fd.Cardinality() == pref.Repeated && fd.IsPacked():
-		switch fd.Kind() {
-		case pref.BoolKind:
-			return coderBoolPackedSliceValue
-		case pref.EnumKind:
-			return coderEnumPackedSliceValue
-		case pref.Int32Kind:
-			return coderInt32PackedSliceValue
-		case pref.Sint32Kind:
-			return coderSint32PackedSliceValue
-		case pref.Uint32Kind:
-			return coderUint32PackedSliceValue
-		case pref.Int64Kind:
-			return coderInt64PackedSliceValue
-		case pref.Sint64Kind:
-			return coderSint64PackedSliceValue
-		case pref.Uint64Kind:
-			return coderUint64PackedSliceValue
-		case pref.Sfixed32Kind:
-			return coderSfixed32PackedSliceValue
-		case pref.Fixed32Kind:
-			return coderFixed32PackedSliceValue
-		case pref.FloatKind:
-			return coderFloatPackedSliceValue
-		case pref.Sfixed64Kind:
-			return coderSfixed64PackedSliceValue
-		case pref.Fixed64Kind:
-			return coderFixed64PackedSliceValue
-		case pref.DoubleKind:
-			return coderDoublePackedSliceValue
-		}
-	default:
-		switch fd.Kind() {
-		default:
-		case pref.BoolKind:
-			return coderBoolValue
-		case pref.EnumKind:
-			return coderEnumValue
-		case pref.Int32Kind:
-			return coderInt32Value
-		case pref.Sint32Kind:
-			return coderSint32Value
-		case pref.Uint32Kind:
-			return coderUint32Value
-		case pref.Int64Kind:
-			return coderInt64Value
-		case pref.Sint64Kind:
-			return coderSint64Value
-		case pref.Uint64Kind:
-			return coderUint64Value
-		case pref.Sfixed32Kind:
-			return coderSfixed32Value
-		case pref.Fixed32Kind:
-			return coderFixed32Value
-		case pref.FloatKind:
-			return coderFloatValue
-		case pref.Sfixed64Kind:
-			return coderSfixed64Value
-		case pref.Fixed64Kind:
-			return coderFixed64Value
-		case pref.DoubleKind:
-			return coderDoubleValue
-		case pref.StringKind:
-			if strs.EnforceUTF8(fd) {
-				return coderStringValueValidateUTF8
-			}
-			return coderStringValue
-		case pref.BytesKind:
-			return coderBytesValue
-		case pref.MessageKind:
-			return coderMessageValue
-		case pref.GroupKind:
-			return coderGroupValue
-		}
-	}
-	panic(fmt.Sprintf("invalid field: no encoder for %v %v %v", fd.FullName(), fd.Cardinality(), fd.Kind()))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go b/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go
deleted file mode 100644
index e118af1..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !purego,!appengine
-
-package impl
-
-// When using unsafe pointers, we can just treat enum values as int32s.
-
-var (
-	coderEnumNoZero      = coderInt32NoZero
-	coderEnum            = coderInt32
-	coderEnumPtr         = coderInt32Ptr
-	coderEnumSlice       = coderInt32Slice
-	coderEnumPackedSlice = coderInt32PackedSlice
-)
diff --git a/vendor/google.golang.org/protobuf/internal/impl/convert.go b/vendor/google.golang.org/protobuf/internal/impl/convert.go
deleted file mode 100644
index 36a90df..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/convert.go
+++ /dev/null
@@ -1,467 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// unwrapper unwraps the value to the underlying value.
-// This is implemented by List and Map.
-type unwrapper interface {
-	protoUnwrap() interface{}
-}
-
-// A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types.
-type Converter interface {
-	// PBValueOf converts a reflect.Value to a protoreflect.Value.
-	PBValueOf(reflect.Value) pref.Value
-
-	// GoValueOf converts a protoreflect.Value to a reflect.Value.
-	GoValueOf(pref.Value) reflect.Value
-
-	// IsValidPB returns whether a protoreflect.Value is compatible with this type.
-	IsValidPB(pref.Value) bool
-
-	// IsValidGo returns whether a reflect.Value is compatible with this type.
-	IsValidGo(reflect.Value) bool
-
-	// New returns a new field value.
-	// For scalars, it returns the default value of the field.
-	// For composite types, it returns a new mutable value.
-	New() pref.Value
-
-	// Zero returns a new field value.
-	// For scalars, it returns the default value of the field.
-	// For composite types, it returns an immutable, empty value.
-	Zero() pref.Value
-}
-
-// NewConverter matches a Go type with a protobuf field and returns a Converter
-// that converts between the two. Enums must be a named int32 kind that
-// implements protoreflect.Enum, and messages must be pointer to a named
-// struct type that implements protoreflect.ProtoMessage.
-//
-// This matcher deliberately supports a wider range of Go types than what
-// protoc-gen-go historically generated to be able to automatically wrap some
-// v1 messages generated by other forks of protoc-gen-go.
-func NewConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
-	switch {
-	case fd.IsList():
-		return newListConverter(t, fd)
-	case fd.IsMap():
-		return newMapConverter(t, fd)
-	default:
-		return newSingularConverter(t, fd)
-	}
-	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
-}
-
-var (
-	boolType    = reflect.TypeOf(bool(false))
-	int32Type   = reflect.TypeOf(int32(0))
-	int64Type   = reflect.TypeOf(int64(0))
-	uint32Type  = reflect.TypeOf(uint32(0))
-	uint64Type  = reflect.TypeOf(uint64(0))
-	float32Type = reflect.TypeOf(float32(0))
-	float64Type = reflect.TypeOf(float64(0))
-	stringType  = reflect.TypeOf(string(""))
-	bytesType   = reflect.TypeOf([]byte(nil))
-	byteType    = reflect.TypeOf(byte(0))
-)
-
-var (
-	boolZero    = pref.ValueOfBool(false)
-	int32Zero   = pref.ValueOfInt32(0)
-	int64Zero   = pref.ValueOfInt64(0)
-	uint32Zero  = pref.ValueOfUint32(0)
-	uint64Zero  = pref.ValueOfUint64(0)
-	float32Zero = pref.ValueOfFloat32(0)
-	float64Zero = pref.ValueOfFloat64(0)
-	stringZero  = pref.ValueOfString("")
-	bytesZero   = pref.ValueOfBytes(nil)
-)
-
-func newSingularConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
-	defVal := func(fd pref.FieldDescriptor, zero pref.Value) pref.Value {
-		if fd.Cardinality() == pref.Repeated {
-			// Default isn't defined for repeated fields.
-			return zero
-		}
-		return fd.Default()
-	}
-	switch fd.Kind() {
-	case pref.BoolKind:
-		if t.Kind() == reflect.Bool {
-			return &boolConverter{t, defVal(fd, boolZero)}
-		}
-	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
-		if t.Kind() == reflect.Int32 {
-			return &int32Converter{t, defVal(fd, int32Zero)}
-		}
-	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-		if t.Kind() == reflect.Int64 {
-			return &int64Converter{t, defVal(fd, int64Zero)}
-		}
-	case pref.Uint32Kind, pref.Fixed32Kind:
-		if t.Kind() == reflect.Uint32 {
-			return &uint32Converter{t, defVal(fd, uint32Zero)}
-		}
-	case pref.Uint64Kind, pref.Fixed64Kind:
-		if t.Kind() == reflect.Uint64 {
-			return &uint64Converter{t, defVal(fd, uint64Zero)}
-		}
-	case pref.FloatKind:
-		if t.Kind() == reflect.Float32 {
-			return &float32Converter{t, defVal(fd, float32Zero)}
-		}
-	case pref.DoubleKind:
-		if t.Kind() == reflect.Float64 {
-			return &float64Converter{t, defVal(fd, float64Zero)}
-		}
-	case pref.StringKind:
-		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
-			return &stringConverter{t, defVal(fd, stringZero)}
-		}
-	case pref.BytesKind:
-		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
-			return &bytesConverter{t, defVal(fd, bytesZero)}
-		}
-	case pref.EnumKind:
-		// Handle enums, which must be a named int32 type.
-		if t.Kind() == reflect.Int32 {
-			return newEnumConverter(t, fd)
-		}
-	case pref.MessageKind, pref.GroupKind:
-		return newMessageConverter(t)
-	}
-	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
-}
-
-type boolConverter struct {
-	goType reflect.Type
-	def    pref.Value
-}
-
-func (c *boolConverter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfBool(v.Bool())
-}
-func (c *boolConverter) GoValueOf(v pref.Value) reflect.Value {
-	return reflect.ValueOf(v.Bool()).Convert(c.goType)
-}
-func (c *boolConverter) IsValidPB(v pref.Value) bool {
-	_, ok := v.Interface().(bool)
-	return ok
-}
-func (c *boolConverter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-func (c *boolConverter) New() pref.Value  { return c.def }
-func (c *boolConverter) Zero() pref.Value { return c.def }
-
-type int32Converter struct {
-	goType reflect.Type
-	def    pref.Value
-}
-
-func (c *int32Converter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfInt32(int32(v.Int()))
-}
-func (c *int32Converter) GoValueOf(v pref.Value) reflect.Value {
-	return reflect.ValueOf(int32(v.Int())).Convert(c.goType)
-}
-func (c *int32Converter) IsValidPB(v pref.Value) bool {
-	_, ok := v.Interface().(int32)
-	return ok
-}
-func (c *int32Converter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-func (c *int32Converter) New() pref.Value  { return c.def }
-func (c *int32Converter) Zero() pref.Value { return c.def }
-
-type int64Converter struct {
-	goType reflect.Type
-	def    pref.Value
-}
-
-func (c *int64Converter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfInt64(int64(v.Int()))
-}
-func (c *int64Converter) GoValueOf(v pref.Value) reflect.Value {
-	return reflect.ValueOf(int64(v.Int())).Convert(c.goType)
-}
-func (c *int64Converter) IsValidPB(v pref.Value) bool {
-	_, ok := v.Interface().(int64)
-	return ok
-}
-func (c *int64Converter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-func (c *int64Converter) New() pref.Value  { return c.def }
-func (c *int64Converter) Zero() pref.Value { return c.def }
-
-type uint32Converter struct {
-	goType reflect.Type
-	def    pref.Value
-}
-
-func (c *uint32Converter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfUint32(uint32(v.Uint()))
-}
-func (c *uint32Converter) GoValueOf(v pref.Value) reflect.Value {
-	return reflect.ValueOf(uint32(v.Uint())).Convert(c.goType)
-}
-func (c *uint32Converter) IsValidPB(v pref.Value) bool {
-	_, ok := v.Interface().(uint32)
-	return ok
-}
-func (c *uint32Converter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-func (c *uint32Converter) New() pref.Value  { return c.def }
-func (c *uint32Converter) Zero() pref.Value { return c.def }
-
-type uint64Converter struct {
-	goType reflect.Type
-	def    pref.Value
-}
-
-func (c *uint64Converter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfUint64(uint64(v.Uint()))
-}
-func (c *uint64Converter) GoValueOf(v pref.Value) reflect.Value {
-	return reflect.ValueOf(uint64(v.Uint())).Convert(c.goType)
-}
-func (c *uint64Converter) IsValidPB(v pref.Value) bool {
-	_, ok := v.Interface().(uint64)
-	return ok
-}
-func (c *uint64Converter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-func (c *uint64Converter) New() pref.Value  { return c.def }
-func (c *uint64Converter) Zero() pref.Value { return c.def }
-
-type float32Converter struct {
-	goType reflect.Type
-	def    pref.Value
-}
-
-func (c *float32Converter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfFloat32(float32(v.Float()))
-}
-func (c *float32Converter) GoValueOf(v pref.Value) reflect.Value {
-	return reflect.ValueOf(float32(v.Float())).Convert(c.goType)
-}
-func (c *float32Converter) IsValidPB(v pref.Value) bool {
-	_, ok := v.Interface().(float32)
-	return ok
-}
-func (c *float32Converter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-func (c *float32Converter) New() pref.Value  { return c.def }
-func (c *float32Converter) Zero() pref.Value { return c.def }
-
-type float64Converter struct {
-	goType reflect.Type
-	def    pref.Value
-}
-
-func (c *float64Converter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfFloat64(float64(v.Float()))
-}
-func (c *float64Converter) GoValueOf(v pref.Value) reflect.Value {
-	return reflect.ValueOf(float64(v.Float())).Convert(c.goType)
-}
-func (c *float64Converter) IsValidPB(v pref.Value) bool {
-	_, ok := v.Interface().(float64)
-	return ok
-}
-func (c *float64Converter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-func (c *float64Converter) New() pref.Value  { return c.def }
-func (c *float64Converter) Zero() pref.Value { return c.def }
-
-type stringConverter struct {
-	goType reflect.Type
-	def    pref.Value
-}
-
-func (c *stringConverter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfString(v.Convert(stringType).String())
-}
-func (c *stringConverter) GoValueOf(v pref.Value) reflect.Value {
-	// pref.Value.String never panics, so we go through an interface
-	// conversion here to check the type.
-	s := v.Interface().(string)
-	if c.goType.Kind() == reflect.Slice && s == "" {
-		return reflect.Zero(c.goType) // ensure empty string is []byte(nil)
-	}
-	return reflect.ValueOf(s).Convert(c.goType)
-}
-func (c *stringConverter) IsValidPB(v pref.Value) bool {
-	_, ok := v.Interface().(string)
-	return ok
-}
-func (c *stringConverter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-func (c *stringConverter) New() pref.Value  { return c.def }
-func (c *stringConverter) Zero() pref.Value { return c.def }
-
-type bytesConverter struct {
-	goType reflect.Type
-	def    pref.Value
-}
-
-func (c *bytesConverter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	if c.goType.Kind() == reflect.String && v.Len() == 0 {
-		return pref.ValueOfBytes(nil) // ensure empty string is []byte(nil)
-	}
-	return pref.ValueOfBytes(v.Convert(bytesType).Bytes())
-}
-func (c *bytesConverter) GoValueOf(v pref.Value) reflect.Value {
-	return reflect.ValueOf(v.Bytes()).Convert(c.goType)
-}
-func (c *bytesConverter) IsValidPB(v pref.Value) bool {
-	_, ok := v.Interface().([]byte)
-	return ok
-}
-func (c *bytesConverter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-func (c *bytesConverter) New() pref.Value  { return c.def }
-func (c *bytesConverter) Zero() pref.Value { return c.def }
-
-type enumConverter struct {
-	goType reflect.Type
-	def    pref.Value
-}
-
-func newEnumConverter(goType reflect.Type, fd pref.FieldDescriptor) Converter {
-	var def pref.Value
-	if fd.Cardinality() == pref.Repeated {
-		def = pref.ValueOfEnum(fd.Enum().Values().Get(0).Number())
-	} else {
-		def = fd.Default()
-	}
-	return &enumConverter{goType, def}
-}
-
-func (c *enumConverter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfEnum(pref.EnumNumber(v.Int()))
-}
-
-func (c *enumConverter) GoValueOf(v pref.Value) reflect.Value {
-	return reflect.ValueOf(v.Enum()).Convert(c.goType)
-}
-
-func (c *enumConverter) IsValidPB(v pref.Value) bool {
-	_, ok := v.Interface().(pref.EnumNumber)
-	return ok
-}
-
-func (c *enumConverter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *enumConverter) New() pref.Value {
-	return c.def
-}
-
-func (c *enumConverter) Zero() pref.Value {
-	return c.def
-}
-
-type messageConverter struct {
-	goType reflect.Type
-}
-
-func newMessageConverter(goType reflect.Type) Converter {
-	return &messageConverter{goType}
-}
-
-func (c *messageConverter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	if m, ok := v.Interface().(pref.ProtoMessage); ok {
-		return pref.ValueOfMessage(m.ProtoReflect())
-	}
-	return pref.ValueOfMessage(legacyWrapMessage(v))
-}
-
-func (c *messageConverter) GoValueOf(v pref.Value) reflect.Value {
-	m := v.Message()
-	var rv reflect.Value
-	if u, ok := m.(unwrapper); ok {
-		rv = reflect.ValueOf(u.protoUnwrap())
-	} else {
-		rv = reflect.ValueOf(m.Interface())
-	}
-	if rv.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
-	}
-	return rv
-}
-
-func (c *messageConverter) IsValidPB(v pref.Value) bool {
-	m := v.Message()
-	var rv reflect.Value
-	if u, ok := m.(unwrapper); ok {
-		rv = reflect.ValueOf(u.protoUnwrap())
-	} else {
-		rv = reflect.ValueOf(m.Interface())
-	}
-	return rv.Type() == c.goType
-}
-
-func (c *messageConverter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *messageConverter) New() pref.Value {
-	return c.PBValueOf(reflect.New(c.goType.Elem()))
-}
-
-func (c *messageConverter) Zero() pref.Value {
-	return c.PBValueOf(reflect.Zero(c.goType))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/convert_list.go b/vendor/google.golang.org/protobuf/internal/impl/convert_list.go
deleted file mode 100644
index 6fccab5..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/convert_list.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-func newListConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
-	switch {
-	case t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Slice:
-		return &listPtrConverter{t, newSingularConverter(t.Elem().Elem(), fd)}
-	case t.Kind() == reflect.Slice:
-		return &listConverter{t, newSingularConverter(t.Elem(), fd)}
-	}
-	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
-}
-
-type listConverter struct {
-	goType reflect.Type // []T
-	c      Converter
-}
-
-func (c *listConverter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	pv := reflect.New(c.goType)
-	pv.Elem().Set(v)
-	return pref.ValueOfList(&listReflect{pv, c.c})
-}
-
-func (c *listConverter) GoValueOf(v pref.Value) reflect.Value {
-	rv := v.List().(*listReflect).v
-	if rv.IsNil() {
-		return reflect.Zero(c.goType)
-	}
-	return rv.Elem()
-}
-
-func (c *listConverter) IsValidPB(v pref.Value) bool {
-	list, ok := v.Interface().(*listReflect)
-	if !ok {
-		return false
-	}
-	return list.v.Type().Elem() == c.goType
-}
-
-func (c *listConverter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *listConverter) New() pref.Value {
-	return pref.ValueOfList(&listReflect{reflect.New(c.goType), c.c})
-}
-
-func (c *listConverter) Zero() pref.Value {
-	return pref.ValueOfList(&listReflect{reflect.Zero(reflect.PtrTo(c.goType)), c.c})
-}
-
-type listPtrConverter struct {
-	goType reflect.Type // *[]T
-	c      Converter
-}
-
-func (c *listPtrConverter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfList(&listReflect{v, c.c})
-}
-
-func (c *listPtrConverter) GoValueOf(v pref.Value) reflect.Value {
-	return v.List().(*listReflect).v
-}
-
-func (c *listPtrConverter) IsValidPB(v pref.Value) bool {
-	list, ok := v.Interface().(*listReflect)
-	if !ok {
-		return false
-	}
-	return list.v.Type() == c.goType
-}
-
-func (c *listPtrConverter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *listPtrConverter) New() pref.Value {
-	return c.PBValueOf(reflect.New(c.goType.Elem()))
-}
-
-func (c *listPtrConverter) Zero() pref.Value {
-	return c.PBValueOf(reflect.Zero(c.goType))
-}
-
-type listReflect struct {
-	v    reflect.Value // *[]T
-	conv Converter
-}
-
-func (ls *listReflect) Len() int {
-	if ls.v.IsNil() {
-		return 0
-	}
-	return ls.v.Elem().Len()
-}
-func (ls *listReflect) Get(i int) pref.Value {
-	return ls.conv.PBValueOf(ls.v.Elem().Index(i))
-}
-func (ls *listReflect) Set(i int, v pref.Value) {
-	ls.v.Elem().Index(i).Set(ls.conv.GoValueOf(v))
-}
-func (ls *listReflect) Append(v pref.Value) {
-	ls.v.Elem().Set(reflect.Append(ls.v.Elem(), ls.conv.GoValueOf(v)))
-}
-func (ls *listReflect) AppendMutable() pref.Value {
-	if _, ok := ls.conv.(*messageConverter); !ok {
-		panic("invalid AppendMutable on list with non-message type")
-	}
-	v := ls.NewElement()
-	ls.Append(v)
-	return v
-}
-func (ls *listReflect) Truncate(i int) {
-	ls.v.Elem().Set(ls.v.Elem().Slice(0, i))
-}
-func (ls *listReflect) NewElement() pref.Value {
-	return ls.conv.New()
-}
-func (ls *listReflect) IsValid() bool {
-	return !ls.v.IsNil()
-}
-func (ls *listReflect) protoUnwrap() interface{} {
-	return ls.v.Interface()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/convert_map.go b/vendor/google.golang.org/protobuf/internal/impl/convert_map.go
deleted file mode 100644
index de06b25..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/convert_map.go
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type mapConverter struct {
-	goType           reflect.Type // map[K]V
-	keyConv, valConv Converter
-}
-
-func newMapConverter(t reflect.Type, fd pref.FieldDescriptor) *mapConverter {
-	if t.Kind() != reflect.Map {
-		panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
-	}
-	return &mapConverter{
-		goType:  t,
-		keyConv: newSingularConverter(t.Key(), fd.MapKey()),
-		valConv: newSingularConverter(t.Elem(), fd.MapValue()),
-	}
-}
-
-func (c *mapConverter) PBValueOf(v reflect.Value) pref.Value {
-	if v.Type() != c.goType {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
-	}
-	return pref.ValueOfMap(&mapReflect{v, c.keyConv, c.valConv})
-}
-
-func (c *mapConverter) GoValueOf(v pref.Value) reflect.Value {
-	return v.Map().(*mapReflect).v
-}
-
-func (c *mapConverter) IsValidPB(v pref.Value) bool {
-	mapv, ok := v.Interface().(*mapReflect)
-	if !ok {
-		return false
-	}
-	return mapv.v.Type() == c.goType
-}
-
-func (c *mapConverter) IsValidGo(v reflect.Value) bool {
-	return v.IsValid() && v.Type() == c.goType
-}
-
-func (c *mapConverter) New() pref.Value {
-	return c.PBValueOf(reflect.MakeMap(c.goType))
-}
-
-func (c *mapConverter) Zero() pref.Value {
-	return c.PBValueOf(reflect.Zero(c.goType))
-}
-
-type mapReflect struct {
-	v       reflect.Value // map[K]V
-	keyConv Converter
-	valConv Converter
-}
-
-func (ms *mapReflect) Len() int {
-	return ms.v.Len()
-}
-func (ms *mapReflect) Has(k pref.MapKey) bool {
-	rk := ms.keyConv.GoValueOf(k.Value())
-	rv := ms.v.MapIndex(rk)
-	return rv.IsValid()
-}
-func (ms *mapReflect) Get(k pref.MapKey) pref.Value {
-	rk := ms.keyConv.GoValueOf(k.Value())
-	rv := ms.v.MapIndex(rk)
-	if !rv.IsValid() {
-		return pref.Value{}
-	}
-	return ms.valConv.PBValueOf(rv)
-}
-func (ms *mapReflect) Set(k pref.MapKey, v pref.Value) {
-	rk := ms.keyConv.GoValueOf(k.Value())
-	rv := ms.valConv.GoValueOf(v)
-	ms.v.SetMapIndex(rk, rv)
-}
-func (ms *mapReflect) Clear(k pref.MapKey) {
-	rk := ms.keyConv.GoValueOf(k.Value())
-	ms.v.SetMapIndex(rk, reflect.Value{})
-}
-func (ms *mapReflect) Mutable(k pref.MapKey) pref.Value {
-	if _, ok := ms.valConv.(*messageConverter); !ok {
-		panic("invalid Mutable on map with non-message value type")
-	}
-	v := ms.Get(k)
-	if !v.IsValid() {
-		v = ms.NewValue()
-		ms.Set(k, v)
-	}
-	return v
-}
-func (ms *mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
-	iter := mapRange(ms.v)
-	for iter.Next() {
-		k := ms.keyConv.PBValueOf(iter.Key()).MapKey()
-		v := ms.valConv.PBValueOf(iter.Value())
-		if !f(k, v) {
-			return
-		}
-	}
-}
-func (ms *mapReflect) NewValue() pref.Value {
-	return ms.valConv.New()
-}
-func (ms *mapReflect) IsValid() bool {
-	return !ms.v.IsNil()
-}
-func (ms *mapReflect) protoUnwrap() interface{} {
-	return ms.v.Interface()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/decode.go b/vendor/google.golang.org/protobuf/internal/impl/decode.go
deleted file mode 100644
index 85ba1d3..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/decode.go
+++ /dev/null
@@ -1,274 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"math/bits"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/flags"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-	"google.golang.org/protobuf/runtime/protoiface"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-type unmarshalOptions struct {
-	flags    protoiface.UnmarshalInputFlags
-	resolver interface {
-		FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
-		FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
-	}
-}
-
-func (o unmarshalOptions) Options() proto.UnmarshalOptions {
-	return proto.UnmarshalOptions{
-		Merge:          true,
-		AllowPartial:   true,
-		DiscardUnknown: o.DiscardUnknown(),
-		Resolver:       o.resolver,
-	}
-}
-
-func (o unmarshalOptions) DiscardUnknown() bool { return o.flags&piface.UnmarshalDiscardUnknown != 0 }
-
-func (o unmarshalOptions) IsDefault() bool {
-	return o.flags == 0 && o.resolver == preg.GlobalTypes
-}
-
-var lazyUnmarshalOptions = unmarshalOptions{
-	resolver: preg.GlobalTypes,
-}
-
-type unmarshalOutput struct {
-	n           int // number of bytes consumed
-	initialized bool
-}
-
-// unmarshal is protoreflect.Methods.Unmarshal.
-func (mi *MessageInfo) unmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) {
-	var p pointer
-	if ms, ok := in.Message.(*messageState); ok {
-		p = ms.pointer()
-	} else {
-		p = in.Message.(*messageReflectWrapper).pointer()
-	}
-	out, err := mi.unmarshalPointer(in.Buf, p, 0, unmarshalOptions{
-		flags:    in.Flags,
-		resolver: in.Resolver,
-	})
-	var flags piface.UnmarshalOutputFlags
-	if out.initialized {
-		flags |= piface.UnmarshalInitialized
-	}
-	return piface.UnmarshalOutput{
-		Flags: flags,
-	}, err
-}
-
-// errUnknown is returned during unmarshaling to indicate a parse error that
-// should result in a field being placed in the unknown fields section (for example,
-// when the wire type doesn't match) as opposed to the entire unmarshal operation
-// failing (for example, when a field extends past the available input).
-//
-// This is a sentinel error which should never be visible to the user.
-var errUnknown = errors.New("unknown")
-
-func (mi *MessageInfo) unmarshalPointer(b []byte, p pointer, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	mi.init()
-	if flags.ProtoLegacy && mi.isMessageSet {
-		return unmarshalMessageSet(mi, b, p, opts)
-	}
-	initialized := true
-	var requiredMask uint64
-	var exts *map[int32]ExtensionField
-	start := len(b)
-	for len(b) > 0 {
-		// Parse the tag (field number and wire type).
-		var tag uint64
-		if b[0] < 0x80 {
-			tag = uint64(b[0])
-			b = b[1:]
-		} else if len(b) >= 2 && b[1] < 128 {
-			tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
-			b = b[2:]
-		} else {
-			var n int
-			tag, n = protowire.ConsumeVarint(b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			b = b[n:]
-		}
-		var num protowire.Number
-		if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
-			return out, errors.New("invalid field number")
-		} else {
-			num = protowire.Number(n)
-		}
-		wtyp := protowire.Type(tag & 7)
-
-		if wtyp == protowire.EndGroupType {
-			if num != groupTag {
-				return out, errors.New("mismatching end group marker")
-			}
-			groupTag = 0
-			break
-		}
-
-		var f *coderFieldInfo
-		if int(num) < len(mi.denseCoderFields) {
-			f = mi.denseCoderFields[num]
-		} else {
-			f = mi.coderFields[num]
-		}
-		var n int
-		err := errUnknown
-		switch {
-		case f != nil:
-			if f.funcs.unmarshal == nil {
-				break
-			}
-			var o unmarshalOutput
-			o, err = f.funcs.unmarshal(b, p.Apply(f.offset), wtyp, f, opts)
-			n = o.n
-			if err != nil {
-				break
-			}
-			requiredMask |= f.validation.requiredBit
-			if f.funcs.isInit != nil && !o.initialized {
-				initialized = false
-			}
-		default:
-			// Possible extension.
-			if exts == nil && mi.extensionOffset.IsValid() {
-				exts = p.Apply(mi.extensionOffset).Extensions()
-				if *exts == nil {
-					*exts = make(map[int32]ExtensionField)
-				}
-			}
-			if exts == nil {
-				break
-			}
-			var o unmarshalOutput
-			o, err = mi.unmarshalExtension(b, num, wtyp, *exts, opts)
-			if err != nil {
-				break
-			}
-			n = o.n
-			if !o.initialized {
-				initialized = false
-			}
-		}
-		if err != nil {
-			if err != errUnknown {
-				return out, err
-			}
-			n = protowire.ConsumeFieldValue(num, wtyp, b)
-			if n < 0 {
-				return out, protowire.ParseError(n)
-			}
-			if !opts.DiscardUnknown() && mi.unknownOffset.IsValid() {
-				u := p.Apply(mi.unknownOffset).Bytes()
-				*u = protowire.AppendTag(*u, num, wtyp)
-				*u = append(*u, b[:n]...)
-			}
-		}
-		b = b[n:]
-	}
-	if groupTag != 0 {
-		return out, errors.New("missing end group marker")
-	}
-	if mi.numRequiredFields > 0 && bits.OnesCount64(requiredMask) != int(mi.numRequiredFields) {
-		initialized = false
-	}
-	if initialized {
-		out.initialized = true
-	}
-	out.n = start - len(b)
-	return out, nil
-}
-
-func (mi *MessageInfo) unmarshalExtension(b []byte, num protowire.Number, wtyp protowire.Type, exts map[int32]ExtensionField, opts unmarshalOptions) (out unmarshalOutput, err error) {
-	x := exts[int32(num)]
-	xt := x.Type()
-	if xt == nil {
-		var err error
-		xt, err = opts.resolver.FindExtensionByNumber(mi.Desc.FullName(), num)
-		if err != nil {
-			if err == preg.NotFound {
-				return out, errUnknown
-			}
-			return out, errors.New("%v: unable to resolve extension %v: %v", mi.Desc.FullName(), num, err)
-		}
-	}
-	xi := getExtensionFieldInfo(xt)
-	if xi.funcs.unmarshal == nil {
-		return out, errUnknown
-	}
-	if flags.LazyUnmarshalExtensions {
-		if opts.IsDefault() && x.canLazy(xt) {
-			out, valid := skipExtension(b, xi, num, wtyp, opts)
-			switch valid {
-			case ValidationValid:
-				if out.initialized {
-					x.appendLazyBytes(xt, xi, num, wtyp, b[:out.n])
-					exts[int32(num)] = x
-					return out, nil
-				}
-			case ValidationInvalid:
-				return out, errors.New("invalid wire format")
-			case ValidationUnknown:
-			}
-		}
-	}
-	ival := x.Value()
-	if !ival.IsValid() && xi.unmarshalNeedsValue {
-		// Create a new message, list, or map value to fill in.
-		// For enums, create a prototype value to let the unmarshal func know the
-		// concrete type.
-		ival = xt.New()
-	}
-	v, out, err := xi.funcs.unmarshal(b, ival, num, wtyp, opts)
-	if err != nil {
-		return out, err
-	}
-	if xi.funcs.isInit == nil {
-		out.initialized = true
-	}
-	x.Set(xt, v)
-	exts[int32(num)] = x
-	return out, nil
-}
-
-func skipExtension(b []byte, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, _ ValidationStatus) {
-	if xi.validation.mi == nil {
-		return out, ValidationUnknown
-	}
-	xi.validation.mi.init()
-	switch xi.validation.typ {
-	case validationTypeMessage:
-		if wtyp != protowire.BytesType {
-			return out, ValidationUnknown
-		}
-		v, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return out, ValidationUnknown
-		}
-		out, st := xi.validation.mi.validate(v, 0, opts)
-		out.n = n
-		return out, st
-	case validationTypeGroup:
-		if wtyp != protowire.StartGroupType {
-			return out, ValidationUnknown
-		}
-		out, st := xi.validation.mi.validate(b, num, opts)
-		return out, st
-	default:
-		return out, ValidationUnknown
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/encode.go b/vendor/google.golang.org/protobuf/internal/impl/encode.go
deleted file mode 100644
index 8c8a794..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/encode.go
+++ /dev/null
@@ -1,199 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"math"
-	"sort"
-	"sync/atomic"
-
-	"google.golang.org/protobuf/internal/flags"
-	proto "google.golang.org/protobuf/proto"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-type marshalOptions struct {
-	flags piface.MarshalInputFlags
-}
-
-func (o marshalOptions) Options() proto.MarshalOptions {
-	return proto.MarshalOptions{
-		AllowPartial:  true,
-		Deterministic: o.Deterministic(),
-		UseCachedSize: o.UseCachedSize(),
-	}
-}
-
-func (o marshalOptions) Deterministic() bool { return o.flags&piface.MarshalDeterministic != 0 }
-func (o marshalOptions) UseCachedSize() bool { return o.flags&piface.MarshalUseCachedSize != 0 }
-
-// size is protoreflect.Methods.Size.
-func (mi *MessageInfo) size(in piface.SizeInput) piface.SizeOutput {
-	var p pointer
-	if ms, ok := in.Message.(*messageState); ok {
-		p = ms.pointer()
-	} else {
-		p = in.Message.(*messageReflectWrapper).pointer()
-	}
-	size := mi.sizePointer(p, marshalOptions{
-		flags: in.Flags,
-	})
-	return piface.SizeOutput{Size: size}
-}
-
-func (mi *MessageInfo) sizePointer(p pointer, opts marshalOptions) (size int) {
-	mi.init()
-	if p.IsNil() {
-		return 0
-	}
-	if opts.UseCachedSize() && mi.sizecacheOffset.IsValid() {
-		if size := atomic.LoadInt32(p.Apply(mi.sizecacheOffset).Int32()); size >= 0 {
-			return int(size)
-		}
-	}
-	return mi.sizePointerSlow(p, opts)
-}
-
-func (mi *MessageInfo) sizePointerSlow(p pointer, opts marshalOptions) (size int) {
-	if flags.ProtoLegacy && mi.isMessageSet {
-		size = sizeMessageSet(mi, p, opts)
-		if mi.sizecacheOffset.IsValid() {
-			atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size))
-		}
-		return size
-	}
-	if mi.extensionOffset.IsValid() {
-		e := p.Apply(mi.extensionOffset).Extensions()
-		size += mi.sizeExtensions(e, opts)
-	}
-	for _, f := range mi.orderedCoderFields {
-		if f.funcs.size == nil {
-			continue
-		}
-		fptr := p.Apply(f.offset)
-		if f.isPointer && fptr.Elem().IsNil() {
-			continue
-		}
-		size += f.funcs.size(fptr, f, opts)
-	}
-	if mi.unknownOffset.IsValid() {
-		u := *p.Apply(mi.unknownOffset).Bytes()
-		size += len(u)
-	}
-	if mi.sizecacheOffset.IsValid() {
-		if size > math.MaxInt32 {
-			// The size is too large for the int32 sizecache field.
-			// We will need to recompute the size when encoding;
-			// unfortunately expensive, but better than invalid output.
-			atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), -1)
-		} else {
-			atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size))
-		}
-	}
-	return size
-}
-
-// marshal is protoreflect.Methods.Marshal.
-func (mi *MessageInfo) marshal(in piface.MarshalInput) (out piface.MarshalOutput, err error) {
-	var p pointer
-	if ms, ok := in.Message.(*messageState); ok {
-		p = ms.pointer()
-	} else {
-		p = in.Message.(*messageReflectWrapper).pointer()
-	}
-	b, err := mi.marshalAppendPointer(in.Buf, p, marshalOptions{
-		flags: in.Flags,
-	})
-	return piface.MarshalOutput{Buf: b}, err
-}
-
-func (mi *MessageInfo) marshalAppendPointer(b []byte, p pointer, opts marshalOptions) ([]byte, error) {
-	mi.init()
-	if p.IsNil() {
-		return b, nil
-	}
-	if flags.ProtoLegacy && mi.isMessageSet {
-		return marshalMessageSet(mi, b, p, opts)
-	}
-	var err error
-	// The old marshaler encodes extensions at beginning.
-	if mi.extensionOffset.IsValid() {
-		e := p.Apply(mi.extensionOffset).Extensions()
-		// TODO: Special handling for MessageSet?
-		b, err = mi.appendExtensions(b, e, opts)
-		if err != nil {
-			return b, err
-		}
-	}
-	for _, f := range mi.orderedCoderFields {
-		if f.funcs.marshal == nil {
-			continue
-		}
-		fptr := p.Apply(f.offset)
-		if f.isPointer && fptr.Elem().IsNil() {
-			continue
-		}
-		b, err = f.funcs.marshal(b, fptr, f, opts)
-		if err != nil {
-			return b, err
-		}
-	}
-	if mi.unknownOffset.IsValid() && !mi.isMessageSet {
-		u := *p.Apply(mi.unknownOffset).Bytes()
-		b = append(b, u...)
-	}
-	return b, nil
-}
-
-func (mi *MessageInfo) sizeExtensions(ext *map[int32]ExtensionField, opts marshalOptions) (n int) {
-	if ext == nil {
-		return 0
-	}
-	for _, x := range *ext {
-		xi := getExtensionFieldInfo(x.Type())
-		if xi.funcs.size == nil {
-			continue
-		}
-		n += xi.funcs.size(x.Value(), xi.tagsize, opts)
-	}
-	return n
-}
-
-func (mi *MessageInfo) appendExtensions(b []byte, ext *map[int32]ExtensionField, opts marshalOptions) ([]byte, error) {
-	if ext == nil {
-		return b, nil
-	}
-
-	switch len(*ext) {
-	case 0:
-		return b, nil
-	case 1:
-		// Fast-path for one extension: Don't bother sorting the keys.
-		var err error
-		for _, x := range *ext {
-			xi := getExtensionFieldInfo(x.Type())
-			b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts)
-		}
-		return b, err
-	default:
-		// Sort the keys to provide a deterministic encoding.
-		// Not sure this is required, but the old code does it.
-		keys := make([]int, 0, len(*ext))
-		for k := range *ext {
-			keys = append(keys, int(k))
-		}
-		sort.Ints(keys)
-		var err error
-		for _, k := range keys {
-			x := (*ext)[int32(k)]
-			xi := getExtensionFieldInfo(x.Type())
-			b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts)
-			if err != nil {
-				return b, err
-			}
-		}
-		return b, nil
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/enum.go b/vendor/google.golang.org/protobuf/internal/impl/enum.go
deleted file mode 100644
index 8c1eab4..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/enum.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"reflect"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type EnumInfo struct {
-	GoReflectType reflect.Type // int32 kind
-	Desc          pref.EnumDescriptor
-}
-
-func (t *EnumInfo) New(n pref.EnumNumber) pref.Enum {
-	return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(pref.Enum)
-}
-func (t *EnumInfo) Descriptor() pref.EnumDescriptor { return t.Desc }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/extension.go b/vendor/google.golang.org/protobuf/internal/impl/extension.go
deleted file mode 100644
index e904fd9..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/extension.go
+++ /dev/null
@@ -1,156 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"reflect"
-	"sync"
-	"sync/atomic"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// ExtensionInfo implements ExtensionType.
-//
-// This type contains a number of exported fields for legacy compatibility.
-// The only non-deprecated use of this type is through the methods of the
-// ExtensionType interface.
-type ExtensionInfo struct {
-	// An ExtensionInfo may exist in several stages of initialization.
-	//
-	// extensionInfoUninitialized: Some or all of the legacy exported
-	// fields may be set, but none of the unexported fields have been
-	// initialized. This is the starting state for an ExtensionInfo
-	// in legacy generated code.
-	//
-	// extensionInfoDescInit: The desc field is set, but other unexported fields
-	// may not be initialized. Legacy exported fields may or may not be set.
-	// This is the starting state for an ExtensionInfo in newly generated code.
-	//
-	// extensionInfoFullInit: The ExtensionInfo is fully initialized.
-	// This state is only entered after lazy initialization is complete.
-	init uint32
-	mu   sync.Mutex
-
-	goType reflect.Type
-	desc   extensionTypeDescriptor
-	conv   Converter
-	info   *extensionFieldInfo // for fast-path method implementations
-
-	// ExtendedType is a typed nil-pointer to the parent message type that
-	// is being extended. It is possible for this to be unpopulated in v2
-	// since the message may no longer implement the MessageV1 interface.
-	//
-	// Deprecated: Use the ExtendedType method instead.
-	ExtendedType piface.MessageV1
-
-	// ExtensionType is the zero value of the extension type.
-	//
-	// For historical reasons, reflect.TypeOf(ExtensionType) and the
-	// type returned by InterfaceOf may not be identical.
-	//
-	// Deprecated: Use InterfaceOf(xt.Zero()) instead.
-	ExtensionType interface{}
-
-	// Field is the field number of the extension.
-	//
-	// Deprecated: Use the Descriptor().Number method instead.
-	Field int32
-
-	// Name is the fully qualified name of extension.
-	//
-	// Deprecated: Use the Descriptor().FullName method instead.
-	Name string
-
-	// Tag is the protobuf struct tag used in the v1 API.
-	//
-	// Deprecated: Do not use.
-	Tag string
-
-	// Filename is the proto filename in which the extension is defined.
-	//
-	// Deprecated: Use Descriptor().ParentFile().Path() instead.
-	Filename string
-}
-
-// Stages of initialization: See the ExtensionInfo.init field.
-const (
-	extensionInfoUninitialized = 0
-	extensionInfoDescInit      = 1
-	extensionInfoFullInit      = 2
-)
-
-func InitExtensionInfo(xi *ExtensionInfo, xd pref.ExtensionDescriptor, goType reflect.Type) {
-	xi.goType = goType
-	xi.desc = extensionTypeDescriptor{xd, xi}
-	xi.init = extensionInfoDescInit
-}
-
-func (xi *ExtensionInfo) New() pref.Value {
-	return xi.lazyInit().New()
-}
-func (xi *ExtensionInfo) Zero() pref.Value {
-	return xi.lazyInit().Zero()
-}
-func (xi *ExtensionInfo) ValueOf(v interface{}) pref.Value {
-	return xi.lazyInit().PBValueOf(reflect.ValueOf(v))
-}
-func (xi *ExtensionInfo) InterfaceOf(v pref.Value) interface{} {
-	return xi.lazyInit().GoValueOf(v).Interface()
-}
-func (xi *ExtensionInfo) IsValidValue(v pref.Value) bool {
-	return xi.lazyInit().IsValidPB(v)
-}
-func (xi *ExtensionInfo) IsValidInterface(v interface{}) bool {
-	return xi.lazyInit().IsValidGo(reflect.ValueOf(v))
-}
-func (xi *ExtensionInfo) TypeDescriptor() pref.ExtensionTypeDescriptor {
-	if atomic.LoadUint32(&xi.init) < extensionInfoDescInit {
-		xi.lazyInitSlow()
-	}
-	return &xi.desc
-}
-
-func (xi *ExtensionInfo) lazyInit() Converter {
-	if atomic.LoadUint32(&xi.init) < extensionInfoFullInit {
-		xi.lazyInitSlow()
-	}
-	return xi.conv
-}
-
-func (xi *ExtensionInfo) lazyInitSlow() {
-	xi.mu.Lock()
-	defer xi.mu.Unlock()
-
-	if xi.init == extensionInfoFullInit {
-		return
-	}
-	defer atomic.StoreUint32(&xi.init, extensionInfoFullInit)
-
-	if xi.desc.ExtensionDescriptor == nil {
-		xi.initFromLegacy()
-	}
-	if !xi.desc.ExtensionDescriptor.IsPlaceholder() {
-		if xi.ExtensionType == nil {
-			xi.initToLegacy()
-		}
-		xi.conv = NewConverter(xi.goType, xi.desc.ExtensionDescriptor)
-		xi.info = makeExtensionFieldInfo(xi.desc.ExtensionDescriptor)
-		xi.info.validation = newValidationInfo(xi.desc.ExtensionDescriptor, xi.goType)
-	}
-}
-
-type extensionTypeDescriptor struct {
-	pref.ExtensionDescriptor
-	xi *ExtensionInfo
-}
-
-func (xtd *extensionTypeDescriptor) Type() pref.ExtensionType {
-	return xtd.xi
-}
-func (xtd *extensionTypeDescriptor) Descriptor() pref.ExtensionDescriptor {
-	return xtd.ExtensionDescriptor
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go
deleted file mode 100644
index f7d7ffb..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go
+++ /dev/null
@@ -1,219 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-
-	"google.golang.org/protobuf/internal/filedesc"
-	"google.golang.org/protobuf/internal/strs"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// legacyEnumName returns the name of enums used in legacy code.
-// It is neither the protobuf full name nor the qualified Go name,
-// but rather an odd hybrid of both.
-func legacyEnumName(ed pref.EnumDescriptor) string {
-	var protoPkg string
-	enumName := string(ed.FullName())
-	if fd := ed.ParentFile(); fd != nil {
-		protoPkg = string(fd.Package())
-		enumName = strings.TrimPrefix(enumName, protoPkg+".")
-	}
-	if protoPkg == "" {
-		return strs.GoCamelCase(enumName)
-	}
-	return protoPkg + "." + strs.GoCamelCase(enumName)
-}
-
-// legacyWrapEnum wraps v as a protoreflect.Enum,
-// where v must be a int32 kind and not implement the v2 API already.
-func legacyWrapEnum(v reflect.Value) pref.Enum {
-	et := legacyLoadEnumType(v.Type())
-	return et.New(pref.EnumNumber(v.Int()))
-}
-
-var legacyEnumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
-
-// legacyLoadEnumType dynamically loads a protoreflect.EnumType for t,
-// where t must be an int32 kind and not implement the v2 API already.
-func legacyLoadEnumType(t reflect.Type) pref.EnumType {
-	// Fast-path: check if a EnumType is cached for this concrete type.
-	if et, ok := legacyEnumTypeCache.Load(t); ok {
-		return et.(pref.EnumType)
-	}
-
-	// Slow-path: derive enum descriptor and initialize EnumType.
-	var et pref.EnumType
-	ed := LegacyLoadEnumDesc(t)
-	et = &legacyEnumType{
-		desc:   ed,
-		goType: t,
-	}
-	if et, ok := legacyEnumTypeCache.LoadOrStore(t, et); ok {
-		return et.(pref.EnumType)
-	}
-	return et
-}
-
-type legacyEnumType struct {
-	desc   pref.EnumDescriptor
-	goType reflect.Type
-	m      sync.Map // map[protoreflect.EnumNumber]proto.Enum
-}
-
-func (t *legacyEnumType) New(n pref.EnumNumber) pref.Enum {
-	if e, ok := t.m.Load(n); ok {
-		return e.(pref.Enum)
-	}
-	e := &legacyEnumWrapper{num: n, pbTyp: t, goTyp: t.goType}
-	t.m.Store(n, e)
-	return e
-}
-func (t *legacyEnumType) Descriptor() pref.EnumDescriptor {
-	return t.desc
-}
-
-type legacyEnumWrapper struct {
-	num   pref.EnumNumber
-	pbTyp pref.EnumType
-	goTyp reflect.Type
-}
-
-func (e *legacyEnumWrapper) Descriptor() pref.EnumDescriptor {
-	return e.pbTyp.Descriptor()
-}
-func (e *legacyEnumWrapper) Type() pref.EnumType {
-	return e.pbTyp
-}
-func (e *legacyEnumWrapper) Number() pref.EnumNumber {
-	return e.num
-}
-func (e *legacyEnumWrapper) ProtoReflect() pref.Enum {
-	return e
-}
-func (e *legacyEnumWrapper) protoUnwrap() interface{} {
-	v := reflect.New(e.goTyp).Elem()
-	v.SetInt(int64(e.num))
-	return v.Interface()
-}
-
-var (
-	_ pref.Enum = (*legacyEnumWrapper)(nil)
-	_ unwrapper = (*legacyEnumWrapper)(nil)
-)
-
-var legacyEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
-
-// LegacyLoadEnumDesc returns an EnumDescriptor derived from the Go type,
-// which must be an int32 kind and not implement the v2 API already.
-//
-// This is exported for testing purposes.
-func LegacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
-	// Fast-path: check if an EnumDescriptor is cached for this concrete type.
-	if ed, ok := legacyEnumDescCache.Load(t); ok {
-		return ed.(pref.EnumDescriptor)
-	}
-
-	// Slow-path: initialize EnumDescriptor from the raw descriptor.
-	ev := reflect.Zero(t).Interface()
-	if _, ok := ev.(pref.Enum); ok {
-		panic(fmt.Sprintf("%v already implements proto.Enum", t))
-	}
-	edV1, ok := ev.(enumV1)
-	if !ok {
-		return aberrantLoadEnumDesc(t)
-	}
-	b, idxs := edV1.EnumDescriptor()
-
-	var ed pref.EnumDescriptor
-	if len(idxs) == 1 {
-		ed = legacyLoadFileDesc(b).Enums().Get(idxs[0])
-	} else {
-		md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
-		for _, i := range idxs[1 : len(idxs)-1] {
-			md = md.Messages().Get(i)
-		}
-		ed = md.Enums().Get(idxs[len(idxs)-1])
-	}
-	if ed, ok := legacyEnumDescCache.LoadOrStore(t, ed); ok {
-		return ed.(protoreflect.EnumDescriptor)
-	}
-	return ed
-}
-
-var aberrantEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
-
-// aberrantLoadEnumDesc returns an EnumDescriptor derived from the Go type,
-// which must not implement protoreflect.Enum or enumV1.
-//
-// If the type does not implement enumV1, then there is no reliable
-// way to derive the original protobuf type information.
-// We are unable to use the global enum registry since it is
-// unfortunately keyed by the protobuf full name, which we also do not know.
-// Thus, this produces some bogus enum descriptor based on the Go type name.
-func aberrantLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
-	// Fast-path: check if an EnumDescriptor is cached for this concrete type.
-	if ed, ok := aberrantEnumDescCache.Load(t); ok {
-		return ed.(pref.EnumDescriptor)
-	}
-
-	// Slow-path: construct a bogus, but unique EnumDescriptor.
-	ed := &filedesc.Enum{L2: new(filedesc.EnumL2)}
-	ed.L0.FullName = AberrantDeriveFullName(t) // e.g., github_com.user.repo.MyEnum
-	ed.L0.ParentFile = filedesc.SurrogateProto3
-	ed.L2.Values.List = append(ed.L2.Values.List, filedesc.EnumValue{})
-
-	// TODO: Use the presence of a UnmarshalJSON method to determine proto2?
-
-	vd := &ed.L2.Values.List[0]
-	vd.L0.FullName = ed.L0.FullName + "_UNKNOWN" // e.g., github_com.user.repo.MyEnum_UNKNOWN
-	vd.L0.ParentFile = ed.L0.ParentFile
-	vd.L0.Parent = ed
-
-	// TODO: We could use the String method to obtain some enum value names by
-	// starting at 0 and print the enum until it produces invalid identifiers.
-	// An exhaustive query is clearly impractical, but can be best-effort.
-
-	if ed, ok := aberrantEnumDescCache.LoadOrStore(t, ed); ok {
-		return ed.(pref.EnumDescriptor)
-	}
-	return ed
-}
-
-// AberrantDeriveFullName derives a fully qualified protobuf name for the given Go type
-// The provided name is not guaranteed to be stable nor universally unique.
-// It should be sufficiently unique within a program.
-//
-// This is exported for testing purposes.
-func AberrantDeriveFullName(t reflect.Type) pref.FullName {
-	sanitize := func(r rune) rune {
-		switch {
-		case r == '/':
-			return '.'
-		case 'a' <= r && r <= 'z', 'A' <= r && r <= 'Z', '0' <= r && r <= '9':
-			return r
-		default:
-			return '_'
-		}
-	}
-	prefix := strings.Map(sanitize, t.PkgPath())
-	suffix := strings.Map(sanitize, t.Name())
-	if suffix == "" {
-		suffix = fmt.Sprintf("UnknownX%X", reflect.ValueOf(t).Pointer())
-	}
-
-	ss := append(strings.Split(prefix, "."), suffix)
-	for i, s := range ss {
-		if s == "" || ('0' <= s[0] && s[0] <= '9') {
-			ss[i] = "x" + s
-		}
-	}
-	return pref.FullName(strings.Join(ss, "."))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_export.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_export.go
deleted file mode 100644
index c3d741c..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_export.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"encoding/binary"
-	"encoding/json"
-	"hash/crc32"
-	"math"
-	"reflect"
-
-	"google.golang.org/protobuf/internal/errors"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// These functions exist to support exported APIs in generated protobufs.
-// While these are deprecated, they cannot be removed for compatibility reasons.
-
-// LegacyEnumName returns the name of enums used in legacy code.
-func (Export) LegacyEnumName(ed pref.EnumDescriptor) string {
-	return legacyEnumName(ed)
-}
-
-// LegacyMessageTypeOf returns the protoreflect.MessageType for m,
-// with name used as the message name if necessary.
-func (Export) LegacyMessageTypeOf(m piface.MessageV1, name pref.FullName) pref.MessageType {
-	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
-		return mv.ProtoReflect().Type()
-	}
-	return legacyLoadMessageInfo(reflect.TypeOf(m), name)
-}
-
-// UnmarshalJSONEnum unmarshals an enum from a JSON-encoded input.
-// The input can either be a string representing the enum value by name,
-// or a number representing the enum number itself.
-func (Export) UnmarshalJSONEnum(ed pref.EnumDescriptor, b []byte) (pref.EnumNumber, error) {
-	if b[0] == '"' {
-		var name pref.Name
-		if err := json.Unmarshal(b, &name); err != nil {
-			return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
-		}
-		ev := ed.Values().ByName(name)
-		if ev == nil {
-			return 0, errors.New("invalid value for enum %v: %s", ed.FullName(), name)
-		}
-		return ev.Number(), nil
-	} else {
-		var num pref.EnumNumber
-		if err := json.Unmarshal(b, &num); err != nil {
-			return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
-		}
-		return num, nil
-	}
-}
-
-// CompressGZIP compresses the input as a GZIP-encoded file.
-// The current implementation does no compression.
-func (Export) CompressGZIP(in []byte) (out []byte) {
-	// RFC 1952, section 2.3.1.
-	var gzipHeader = [10]byte{0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff}
-
-	// RFC 1951, section 3.2.4.
-	var blockHeader [5]byte
-	const maxBlockSize = math.MaxUint16
-	numBlocks := 1 + len(in)/maxBlockSize
-
-	// RFC 1952, section 2.3.1.
-	var gzipFooter [8]byte
-	binary.LittleEndian.PutUint32(gzipFooter[0:4], crc32.ChecksumIEEE(in))
-	binary.LittleEndian.PutUint32(gzipFooter[4:8], uint32(len(in)))
-
-	// Encode the input without compression using raw DEFLATE blocks.
-	out = make([]byte, 0, len(gzipHeader)+len(blockHeader)*numBlocks+len(in)+len(gzipFooter))
-	out = append(out, gzipHeader[:]...)
-	for blockHeader[0] == 0 {
-		blockSize := maxBlockSize
-		if blockSize > len(in) {
-			blockHeader[0] = 0x01 // final bit per RFC 1951, section 3.2.3.
-			blockSize = len(in)
-		}
-		binary.LittleEndian.PutUint16(blockHeader[1:3], uint16(blockSize)^0x0000)
-		binary.LittleEndian.PutUint16(blockHeader[3:5], uint16(blockSize)^0xffff)
-		out = append(out, blockHeader[:]...)
-		out = append(out, in[:blockSize]...)
-		in = in[blockSize:]
-	}
-	out = append(out, gzipFooter[:]...)
-	return out
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go
deleted file mode 100644
index 61757ce..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"reflect"
-
-	"google.golang.org/protobuf/internal/descopts"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	ptag "google.golang.org/protobuf/internal/encoding/tag"
-	"google.golang.org/protobuf/internal/filedesc"
-	"google.golang.org/protobuf/internal/pragma"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-func (xi *ExtensionInfo) initToLegacy() {
-	xd := xi.desc
-	var parent piface.MessageV1
-	messageName := xd.ContainingMessage().FullName()
-	if mt, _ := preg.GlobalTypes.FindMessageByName(messageName); mt != nil {
-		// Create a new parent message and unwrap it if possible.
-		mv := mt.New().Interface()
-		t := reflect.TypeOf(mv)
-		if mv, ok := mv.(unwrapper); ok {
-			t = reflect.TypeOf(mv.protoUnwrap())
-		}
-
-		// Check whether the message implements the legacy v1 Message interface.
-		mz := reflect.Zero(t).Interface()
-		if mz, ok := mz.(piface.MessageV1); ok {
-			parent = mz
-		}
-	}
-
-	// Determine the v1 extension type, which is unfortunately not the same as
-	// the v2 ExtensionType.GoType.
-	extType := xi.goType
-	switch extType.Kind() {
-	case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
-		extType = reflect.PtrTo(extType) // T -> *T for singular scalar fields
-	}
-
-	// Reconstruct the legacy enum full name.
-	var enumName string
-	if xd.Kind() == pref.EnumKind {
-		enumName = legacyEnumName(xd.Enum())
-	}
-
-	// Derive the proto file that the extension was declared within.
-	var filename string
-	if fd := xd.ParentFile(); fd != nil {
-		filename = fd.Path()
-	}
-
-	// For MessageSet extensions, the name used is the parent message.
-	name := xd.FullName()
-	if messageset.IsMessageSetExtension(xd) {
-		name = name.Parent()
-	}
-
-	xi.ExtendedType = parent
-	xi.ExtensionType = reflect.Zero(extType).Interface()
-	xi.Field = int32(xd.Number())
-	xi.Name = string(name)
-	xi.Tag = ptag.Marshal(xd, enumName)
-	xi.Filename = filename
-}
-
-// initFromLegacy initializes an ExtensionInfo from
-// the contents of the deprecated exported fields of the type.
-func (xi *ExtensionInfo) initFromLegacy() {
-	// The v1 API returns "type incomplete" descriptors where only the
-	// field number is specified. In such a case, use a placeholder.
-	if xi.ExtendedType == nil || xi.ExtensionType == nil {
-		xd := placeholderExtension{
-			name:   pref.FullName(xi.Name),
-			number: pref.FieldNumber(xi.Field),
-		}
-		xi.desc = extensionTypeDescriptor{xd, xi}
-		return
-	}
-
-	// Resolve enum or message dependencies.
-	var ed pref.EnumDescriptor
-	var md pref.MessageDescriptor
-	t := reflect.TypeOf(xi.ExtensionType)
-	isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
-	isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
-	if isOptional || isRepeated {
-		t = t.Elem()
-	}
-	switch v := reflect.Zero(t).Interface().(type) {
-	case pref.Enum:
-		ed = v.Descriptor()
-	case enumV1:
-		ed = LegacyLoadEnumDesc(t)
-	case pref.ProtoMessage:
-		md = v.ProtoReflect().Descriptor()
-	case messageV1:
-		md = LegacyLoadMessageDesc(t)
-	}
-
-	// Derive basic field information from the struct tag.
-	var evs pref.EnumValueDescriptors
-	if ed != nil {
-		evs = ed.Values()
-	}
-	fd := ptag.Unmarshal(xi.Tag, t, evs).(*filedesc.Field)
-
-	// Construct a v2 ExtensionType.
-	xd := &filedesc.Extension{L2: new(filedesc.ExtensionL2)}
-	xd.L0.ParentFile = filedesc.SurrogateProto2
-	xd.L0.FullName = pref.FullName(xi.Name)
-	xd.L1.Number = pref.FieldNumber(xi.Field)
-	xd.L1.Cardinality = fd.L1.Cardinality
-	xd.L1.Kind = fd.L1.Kind
-	xd.L2.IsPacked = fd.L1.IsPacked
-	xd.L2.Default = fd.L1.Default
-	xd.L1.Extendee = Export{}.MessageDescriptorOf(xi.ExtendedType)
-	xd.L2.Enum = ed
-	xd.L2.Message = md
-
-	// Derive real extension field name for MessageSets.
-	if messageset.IsMessageSet(xd.L1.Extendee) && md.FullName() == xd.L0.FullName {
-		xd.L0.FullName = xd.L0.FullName.Append(messageset.ExtensionName)
-	}
-
-	tt := reflect.TypeOf(xi.ExtensionType)
-	if isOptional {
-		tt = tt.Elem()
-	}
-	xi.goType = tt
-	xi.desc = extensionTypeDescriptor{xd, xi}
-}
-
-type placeholderExtension struct {
-	name   pref.FullName
-	number pref.FieldNumber
-}
-
-func (x placeholderExtension) ParentFile() pref.FileDescriptor            { return nil }
-func (x placeholderExtension) Parent() pref.Descriptor                    { return nil }
-func (x placeholderExtension) Index() int                                 { return 0 }
-func (x placeholderExtension) Syntax() pref.Syntax                        { return 0 }
-func (x placeholderExtension) Name() pref.Name                            { return x.name.Name() }
-func (x placeholderExtension) FullName() pref.FullName                    { return x.name }
-func (x placeholderExtension) IsPlaceholder() bool                        { return true }
-func (x placeholderExtension) Options() pref.ProtoMessage                 { return descopts.Field }
-func (x placeholderExtension) Number() pref.FieldNumber                   { return x.number }
-func (x placeholderExtension) Cardinality() pref.Cardinality              { return 0 }
-func (x placeholderExtension) Kind() pref.Kind                            { return 0 }
-func (x placeholderExtension) HasJSONName() bool                          { return false }
-func (x placeholderExtension) JSONName() string                           { return "" }
-func (x placeholderExtension) HasPresence() bool                          { return false }
-func (x placeholderExtension) HasOptionalKeyword() bool                   { return false }
-func (x placeholderExtension) IsExtension() bool                          { return true }
-func (x placeholderExtension) IsWeak() bool                               { return false }
-func (x placeholderExtension) IsPacked() bool                             { return false }
-func (x placeholderExtension) IsList() bool                               { return false }
-func (x placeholderExtension) IsMap() bool                                { return false }
-func (x placeholderExtension) MapKey() pref.FieldDescriptor               { return nil }
-func (x placeholderExtension) MapValue() pref.FieldDescriptor             { return nil }
-func (x placeholderExtension) HasDefault() bool                           { return false }
-func (x placeholderExtension) Default() pref.Value                        { return pref.Value{} }
-func (x placeholderExtension) DefaultEnumValue() pref.EnumValueDescriptor { return nil }
-func (x placeholderExtension) ContainingOneof() pref.OneofDescriptor      { return nil }
-func (x placeholderExtension) ContainingMessage() pref.MessageDescriptor  { return nil }
-func (x placeholderExtension) Enum() pref.EnumDescriptor                  { return nil }
-func (x placeholderExtension) Message() pref.MessageDescriptor            { return nil }
-func (x placeholderExtension) ProtoType(pref.FieldDescriptor)             { return }
-func (x placeholderExtension) ProtoInternal(pragma.DoNotImplement)        { return }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go
deleted file mode 100644
index 9ab0910..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"bytes"
-	"compress/gzip"
-	"io/ioutil"
-	"sync"
-
-	"google.golang.org/protobuf/internal/filedesc"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// Every enum and message type generated by protoc-gen-go since commit 2fc053c5
-// on February 25th, 2016 has had a method to get the raw descriptor.
-// Types that were not generated by protoc-gen-go or were generated prior
-// to that version are not supported.
-//
-// The []byte returned is the encoded form of a FileDescriptorProto message
-// compressed using GZIP. The []int is the path from the top-level file
-// to the specific message or enum declaration.
-type (
-	enumV1 interface {
-		EnumDescriptor() ([]byte, []int)
-	}
-	messageV1 interface {
-		Descriptor() ([]byte, []int)
-	}
-)
-
-var legacyFileDescCache sync.Map // map[*byte]protoreflect.FileDescriptor
-
-// legacyLoadFileDesc unmarshals b as a compressed FileDescriptorProto message.
-//
-// This assumes that b is immutable and that b does not refer to part of a
-// concatenated series of GZIP files (which would require shenanigans that
-// rely on the concatenation properties of both protobufs and GZIP).
-// File descriptors generated by protoc-gen-go do not rely on that property.
-func legacyLoadFileDesc(b []byte) protoreflect.FileDescriptor {
-	// Fast-path: check whether we already have a cached file descriptor.
-	if fd, ok := legacyFileDescCache.Load(&b[0]); ok {
-		return fd.(protoreflect.FileDescriptor)
-	}
-
-	// Slow-path: decompress and unmarshal the file descriptor proto.
-	zr, err := gzip.NewReader(bytes.NewReader(b))
-	if err != nil {
-		panic(err)
-	}
-	b2, err := ioutil.ReadAll(zr)
-	if err != nil {
-		panic(err)
-	}
-
-	fd := filedesc.Builder{
-		RawDescriptor: b2,
-		FileRegistry:  resolverOnly{protoregistry.GlobalFiles}, // do not register back to global registry
-	}.Build().File
-	if fd, ok := legacyFileDescCache.LoadOrStore(&b[0], fd); ok {
-		return fd.(protoreflect.FileDescriptor)
-	}
-	return fd
-}
-
-type resolverOnly struct {
-	reg *protoregistry.Files
-}
-
-func (r resolverOnly) FindFileByPath(path string) (protoreflect.FileDescriptor, error) {
-	return r.reg.FindFileByPath(path)
-}
-func (r resolverOnly) FindDescriptorByName(name protoreflect.FullName) (protoreflect.Descriptor, error) {
-	return r.reg.FindDescriptorByName(name)
-}
-func (resolverOnly) RegisterFile(protoreflect.FileDescriptor) error {
-	return nil
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go b/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go
deleted file mode 100644
index 06c68e1..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go
+++ /dev/null
@@ -1,502 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-
-	"google.golang.org/protobuf/internal/descopts"
-	ptag "google.golang.org/protobuf/internal/encoding/tag"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/filedesc"
-	"google.golang.org/protobuf/internal/strs"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoiface"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// legacyWrapMessage wraps v as a protoreflect.Message,
-// where v must be a *struct kind and not implement the v2 API already.
-func legacyWrapMessage(v reflect.Value) pref.Message {
-	typ := v.Type()
-	if typ.Kind() != reflect.Ptr || typ.Elem().Kind() != reflect.Struct {
-		return aberrantMessage{v: v}
-	}
-	mt := legacyLoadMessageInfo(typ, "")
-	return mt.MessageOf(v.Interface())
-}
-
-var legacyMessageTypeCache sync.Map // map[reflect.Type]*MessageInfo
-
-// legacyLoadMessageInfo dynamically loads a *MessageInfo for t,
-// where t must be a *struct kind and not implement the v2 API already.
-// The provided name is used if it cannot be determined from the message.
-func legacyLoadMessageInfo(t reflect.Type, name pref.FullName) *MessageInfo {
-	// Fast-path: check if a MessageInfo is cached for this concrete type.
-	if mt, ok := legacyMessageTypeCache.Load(t); ok {
-		return mt.(*MessageInfo)
-	}
-
-	// Slow-path: derive message descriptor and initialize MessageInfo.
-	mi := &MessageInfo{
-		Desc:          legacyLoadMessageDesc(t, name),
-		GoReflectType: t,
-	}
-
-	v := reflect.Zero(t).Interface()
-	if _, ok := v.(legacyMarshaler); ok {
-		mi.methods.Marshal = legacyMarshal
-
-		// We have no way to tell whether the type's Marshal method
-		// supports deterministic serialization or not, but this
-		// preserves the v1 implementation's behavior of always
-		// calling Marshal methods when present.
-		mi.methods.Flags |= piface.SupportMarshalDeterministic
-	}
-	if _, ok := v.(legacyUnmarshaler); ok {
-		mi.methods.Unmarshal = legacyUnmarshal
-	}
-	if _, ok := v.(legacyMerger); ok {
-		mi.methods.Merge = legacyMerge
-	}
-
-	if mi, ok := legacyMessageTypeCache.LoadOrStore(t, mi); ok {
-		return mi.(*MessageInfo)
-	}
-	return mi
-}
-
-var legacyMessageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
-
-// LegacyLoadMessageDesc returns an MessageDescriptor derived from the Go type,
-// which must be a *struct kind and not implement the v2 API already.
-//
-// This is exported for testing purposes.
-func LegacyLoadMessageDesc(t reflect.Type) pref.MessageDescriptor {
-	return legacyLoadMessageDesc(t, "")
-}
-func legacyLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
-	// Fast-path: check if a MessageDescriptor is cached for this concrete type.
-	if mi, ok := legacyMessageDescCache.Load(t); ok {
-		return mi.(pref.MessageDescriptor)
-	}
-
-	// Slow-path: initialize MessageDescriptor from the raw descriptor.
-	mv := reflect.Zero(t).Interface()
-	if _, ok := mv.(pref.ProtoMessage); ok {
-		panic(fmt.Sprintf("%v already implements proto.Message", t))
-	}
-	mdV1, ok := mv.(messageV1)
-	if !ok {
-		return aberrantLoadMessageDesc(t, name)
-	}
-
-	// If this is a dynamic message type where there isn't a 1-1 mapping between
-	// Go and protobuf types, calling the Descriptor method on the zero value of
-	// the message type isn't likely to work. If it panics, swallow the panic and
-	// continue as if the Descriptor method wasn't present.
-	b, idxs := func() ([]byte, []int) {
-		defer func() {
-			recover()
-		}()
-		return mdV1.Descriptor()
-	}()
-	if b == nil {
-		return aberrantLoadMessageDesc(t, name)
-	}
-
-	// If the Go type has no fields, then this might be a proto3 empty message
-	// from before the size cache was added. If there are any fields, check to
-	// see that at least one of them looks like something we generated.
-	if nfield := t.Elem().NumField(); nfield > 0 {
-		hasProtoField := false
-		for i := 0; i < nfield; i++ {
-			f := t.Elem().Field(i)
-			if f.Tag.Get("protobuf") != "" || f.Tag.Get("protobuf_oneof") != "" || strings.HasPrefix(f.Name, "XXX_") {
-				hasProtoField = true
-				break
-			}
-		}
-		if !hasProtoField {
-			return aberrantLoadMessageDesc(t, name)
-		}
-	}
-
-	md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
-	for _, i := range idxs[1:] {
-		md = md.Messages().Get(i)
-	}
-	if name != "" && md.FullName() != name {
-		panic(fmt.Sprintf("mismatching message name: got %v, want %v", md.FullName(), name))
-	}
-	if md, ok := legacyMessageDescCache.LoadOrStore(t, md); ok {
-		return md.(protoreflect.MessageDescriptor)
-	}
-	return md
-}
-
-var (
-	aberrantMessageDescLock  sync.Mutex
-	aberrantMessageDescCache map[reflect.Type]protoreflect.MessageDescriptor
-)
-
-// aberrantLoadMessageDesc returns an MessageDescriptor derived from the Go type,
-// which must not implement protoreflect.ProtoMessage or messageV1.
-//
-// This is a best-effort derivation of the message descriptor using the protobuf
-// tags on the struct fields.
-func aberrantLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
-	aberrantMessageDescLock.Lock()
-	defer aberrantMessageDescLock.Unlock()
-	if aberrantMessageDescCache == nil {
-		aberrantMessageDescCache = make(map[reflect.Type]protoreflect.MessageDescriptor)
-	}
-	return aberrantLoadMessageDescReentrant(t, name)
-}
-func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
-	// Fast-path: check if an MessageDescriptor is cached for this concrete type.
-	if md, ok := aberrantMessageDescCache[t]; ok {
-		return md
-	}
-
-	// Slow-path: construct a descriptor from the Go struct type (best-effort).
-	// Cache the MessageDescriptor early on so that we can resolve internal
-	// cyclic references.
-	md := &filedesc.Message{L2: new(filedesc.MessageL2)}
-	md.L0.FullName = aberrantDeriveMessageName(t, name)
-	md.L0.ParentFile = filedesc.SurrogateProto2
-	aberrantMessageDescCache[t] = md
-
-	if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
-		return md
-	}
-
-	// Try to determine if the message is using proto3 by checking scalars.
-	for i := 0; i < t.Elem().NumField(); i++ {
-		f := t.Elem().Field(i)
-		if tag := f.Tag.Get("protobuf"); tag != "" {
-			switch f.Type.Kind() {
-			case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
-				md.L0.ParentFile = filedesc.SurrogateProto3
-			}
-			for _, s := range strings.Split(tag, ",") {
-				if s == "proto3" {
-					md.L0.ParentFile = filedesc.SurrogateProto3
-				}
-			}
-		}
-	}
-
-	// Obtain a list of oneof wrapper types.
-	var oneofWrappers []reflect.Type
-	for _, method := range []string{"XXX_OneofFuncs", "XXX_OneofWrappers"} {
-		if fn, ok := t.MethodByName(method); ok {
-			for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
-				if vs, ok := v.Interface().([]interface{}); ok {
-					for _, v := range vs {
-						oneofWrappers = append(oneofWrappers, reflect.TypeOf(v))
-					}
-				}
-			}
-		}
-	}
-
-	// Obtain a list of the extension ranges.
-	if fn, ok := t.MethodByName("ExtensionRangeArray"); ok {
-		vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
-		for i := 0; i < vs.Len(); i++ {
-			v := vs.Index(i)
-			md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, [2]pref.FieldNumber{
-				pref.FieldNumber(v.FieldByName("Start").Int()),
-				pref.FieldNumber(v.FieldByName("End").Int() + 1),
-			})
-			md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, nil)
-		}
-	}
-
-	// Derive the message fields by inspecting the struct fields.
-	for i := 0; i < t.Elem().NumField(); i++ {
-		f := t.Elem().Field(i)
-		if tag := f.Tag.Get("protobuf"); tag != "" {
-			tagKey := f.Tag.Get("protobuf_key")
-			tagVal := f.Tag.Get("protobuf_val")
-			aberrantAppendField(md, f.Type, tag, tagKey, tagVal)
-		}
-		if tag := f.Tag.Get("protobuf_oneof"); tag != "" {
-			n := len(md.L2.Oneofs.List)
-			md.L2.Oneofs.List = append(md.L2.Oneofs.List, filedesc.Oneof{})
-			od := &md.L2.Oneofs.List[n]
-			od.L0.FullName = md.FullName().Append(pref.Name(tag))
-			od.L0.ParentFile = md.L0.ParentFile
-			od.L0.Parent = md
-			od.L0.Index = n
-
-			for _, t := range oneofWrappers {
-				if t.Implements(f.Type) {
-					f := t.Elem().Field(0)
-					if tag := f.Tag.Get("protobuf"); tag != "" {
-						aberrantAppendField(md, f.Type, tag, "", "")
-						fd := &md.L2.Fields.List[len(md.L2.Fields.List)-1]
-						fd.L1.ContainingOneof = od
-						od.L1.Fields.List = append(od.L1.Fields.List, fd)
-					}
-				}
-			}
-		}
-	}
-
-	return md
-}
-
-func aberrantDeriveMessageName(t reflect.Type, name pref.FullName) pref.FullName {
-	if name.IsValid() {
-		return name
-	}
-	func() {
-		defer func() { recover() }() // swallow possible nil panics
-		if m, ok := reflect.Zero(t).Interface().(interface{ XXX_MessageName() string }); ok {
-			name = pref.FullName(m.XXX_MessageName())
-		}
-	}()
-	if name.IsValid() {
-		return name
-	}
-	if t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-	return AberrantDeriveFullName(t)
-}
-
-func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey, tagVal string) {
-	t := goType
-	isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
-	isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
-	if isOptional || isRepeated {
-		t = t.Elem()
-	}
-	fd := ptag.Unmarshal(tag, t, placeholderEnumValues{}).(*filedesc.Field)
-
-	// Append field descriptor to the message.
-	n := len(md.L2.Fields.List)
-	md.L2.Fields.List = append(md.L2.Fields.List, *fd)
-	fd = &md.L2.Fields.List[n]
-	fd.L0.FullName = md.FullName().Append(fd.Name())
-	fd.L0.ParentFile = md.L0.ParentFile
-	fd.L0.Parent = md
-	fd.L0.Index = n
-
-	if fd.L1.IsWeak || fd.L1.HasPacked {
-		fd.L1.Options = func() pref.ProtoMessage {
-			opts := descopts.Field.ProtoReflect().New()
-			if fd.L1.IsWeak {
-				opts.Set(opts.Descriptor().Fields().ByName("weak"), protoreflect.ValueOfBool(true))
-			}
-			if fd.L1.HasPacked {
-				opts.Set(opts.Descriptor().Fields().ByName("packed"), protoreflect.ValueOfBool(fd.L1.IsPacked))
-			}
-			return opts.Interface()
-		}
-	}
-
-	// Populate Enum and Message.
-	if fd.Enum() == nil && fd.Kind() == pref.EnumKind {
-		switch v := reflect.Zero(t).Interface().(type) {
-		case pref.Enum:
-			fd.L1.Enum = v.Descriptor()
-		default:
-			fd.L1.Enum = LegacyLoadEnumDesc(t)
-		}
-	}
-	if fd.Message() == nil && (fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind) {
-		switch v := reflect.Zero(t).Interface().(type) {
-		case pref.ProtoMessage:
-			fd.L1.Message = v.ProtoReflect().Descriptor()
-		case messageV1:
-			fd.L1.Message = LegacyLoadMessageDesc(t)
-		default:
-			if t.Kind() == reflect.Map {
-				n := len(md.L1.Messages.List)
-				md.L1.Messages.List = append(md.L1.Messages.List, filedesc.Message{L2: new(filedesc.MessageL2)})
-				md2 := &md.L1.Messages.List[n]
-				md2.L0.FullName = md.FullName().Append(pref.Name(strs.MapEntryName(string(fd.Name()))))
-				md2.L0.ParentFile = md.L0.ParentFile
-				md2.L0.Parent = md
-				md2.L0.Index = n
-
-				md2.L1.IsMapEntry = true
-				md2.L2.Options = func() pref.ProtoMessage {
-					opts := descopts.Message.ProtoReflect().New()
-					opts.Set(opts.Descriptor().Fields().ByName("map_entry"), protoreflect.ValueOfBool(true))
-					return opts.Interface()
-				}
-
-				aberrantAppendField(md2, t.Key(), tagKey, "", "")
-				aberrantAppendField(md2, t.Elem(), tagVal, "", "")
-
-				fd.L1.Message = md2
-				break
-			}
-			fd.L1.Message = aberrantLoadMessageDescReentrant(t, "")
-		}
-	}
-}
-
-type placeholderEnumValues struct {
-	protoreflect.EnumValueDescriptors
-}
-
-func (placeholderEnumValues) ByNumber(n pref.EnumNumber) pref.EnumValueDescriptor {
-	return filedesc.PlaceholderEnumValue(pref.FullName(fmt.Sprintf("UNKNOWN_%d", n)))
-}
-
-// legacyMarshaler is the proto.Marshaler interface superseded by protoiface.Methoder.
-type legacyMarshaler interface {
-	Marshal() ([]byte, error)
-}
-
-// legacyUnmarshaler is the proto.Unmarshaler interface superseded by protoiface.Methoder.
-type legacyUnmarshaler interface {
-	Unmarshal([]byte) error
-}
-
-// legacyMerger is the proto.Merger interface superseded by protoiface.Methoder.
-type legacyMerger interface {
-	Merge(protoiface.MessageV1)
-}
-
-var legacyProtoMethods = &piface.Methods{
-	Marshal:   legacyMarshal,
-	Unmarshal: legacyUnmarshal,
-	Merge:     legacyMerge,
-
-	// We have no way to tell whether the type's Marshal method
-	// supports deterministic serialization or not, but this
-	// preserves the v1 implementation's behavior of always
-	// calling Marshal methods when present.
-	Flags: piface.SupportMarshalDeterministic,
-}
-
-func legacyMarshal(in piface.MarshalInput) (piface.MarshalOutput, error) {
-	v := in.Message.(unwrapper).protoUnwrap()
-	marshaler, ok := v.(legacyMarshaler)
-	if !ok {
-		return piface.MarshalOutput{}, errors.New("%T does not implement Marshal", v)
-	}
-	out, err := marshaler.Marshal()
-	if in.Buf != nil {
-		out = append(in.Buf, out...)
-	}
-	return piface.MarshalOutput{
-		Buf: out,
-	}, err
-}
-
-func legacyUnmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) {
-	v := in.Message.(unwrapper).protoUnwrap()
-	unmarshaler, ok := v.(legacyUnmarshaler)
-	if !ok {
-		return piface.UnmarshalOutput{}, errors.New("%T does not implement Marshal", v)
-	}
-	return piface.UnmarshalOutput{}, unmarshaler.Unmarshal(in.Buf)
-}
-
-func legacyMerge(in piface.MergeInput) piface.MergeOutput {
-	dstv := in.Destination.(unwrapper).protoUnwrap()
-	merger, ok := dstv.(legacyMerger)
-	if !ok {
-		return piface.MergeOutput{}
-	}
-	merger.Merge(Export{}.ProtoMessageV1Of(in.Source))
-	return piface.MergeOutput{Flags: piface.MergeComplete}
-}
-
-// aberrantMessageType implements MessageType for all types other than pointer-to-struct.
-type aberrantMessageType struct {
-	t reflect.Type
-}
-
-func (mt aberrantMessageType) New() pref.Message {
-	return aberrantMessage{reflect.Zero(mt.t)}
-}
-func (mt aberrantMessageType) Zero() pref.Message {
-	return aberrantMessage{reflect.Zero(mt.t)}
-}
-func (mt aberrantMessageType) GoType() reflect.Type {
-	return mt.t
-}
-func (mt aberrantMessageType) Descriptor() pref.MessageDescriptor {
-	return LegacyLoadMessageDesc(mt.t)
-}
-
-// aberrantMessage implements Message for all types other than pointer-to-struct.
-//
-// When the underlying type implements legacyMarshaler or legacyUnmarshaler,
-// the aberrant Message can be marshaled or unmarshaled. Otherwise, there is
-// not much that can be done with values of this type.
-type aberrantMessage struct {
-	v reflect.Value
-}
-
-func (m aberrantMessage) ProtoReflect() pref.Message {
-	return m
-}
-
-func (m aberrantMessage) Descriptor() pref.MessageDescriptor {
-	return LegacyLoadMessageDesc(m.v.Type())
-}
-func (m aberrantMessage) Type() pref.MessageType {
-	return aberrantMessageType{m.v.Type()}
-}
-func (m aberrantMessage) New() pref.Message {
-	return aberrantMessage{reflect.Zero(m.v.Type())}
-}
-func (m aberrantMessage) Interface() pref.ProtoMessage {
-	return m
-}
-func (m aberrantMessage) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
-}
-func (m aberrantMessage) Has(pref.FieldDescriptor) bool {
-	panic("invalid field descriptor")
-}
-func (m aberrantMessage) Clear(pref.FieldDescriptor) {
-	panic("invalid field descriptor")
-}
-func (m aberrantMessage) Get(pref.FieldDescriptor) pref.Value {
-	panic("invalid field descriptor")
-}
-func (m aberrantMessage) Set(pref.FieldDescriptor, pref.Value) {
-	panic("invalid field descriptor")
-}
-func (m aberrantMessage) Mutable(pref.FieldDescriptor) pref.Value {
-	panic("invalid field descriptor")
-}
-func (m aberrantMessage) NewField(pref.FieldDescriptor) pref.Value {
-	panic("invalid field descriptor")
-}
-func (m aberrantMessage) WhichOneof(pref.OneofDescriptor) pref.FieldDescriptor {
-	panic("invalid oneof descriptor")
-}
-func (m aberrantMessage) GetUnknown() pref.RawFields {
-	return nil
-}
-func (m aberrantMessage) SetUnknown(pref.RawFields) {
-	// SetUnknown discards its input on messages which don't support unknown field storage.
-}
-func (m aberrantMessage) IsValid() bool {
-	// An invalid message is a read-only, empty message. Since we don't know anything
-	// about the alleged contents of this message, we can't say with confidence that
-	// it is invalid in this sense. Therefore, report it as valid.
-	return true
-}
-func (m aberrantMessage) ProtoMethods() *piface.Methods {
-	return legacyProtoMethods
-}
-func (m aberrantMessage) protoUnwrap() interface{} {
-	return m.v.Interface()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/merge.go b/vendor/google.golang.org/protobuf/internal/impl/merge.go
deleted file mode 100644
index cdc4267..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/merge.go
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-
-	"google.golang.org/protobuf/proto"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-type mergeOptions struct{}
-
-func (o mergeOptions) Merge(dst, src proto.Message) {
-	proto.Merge(dst, src)
-}
-
-// merge is protoreflect.Methods.Merge.
-func (mi *MessageInfo) merge(in piface.MergeInput) piface.MergeOutput {
-	dp, ok := mi.getPointer(in.Destination)
-	if !ok {
-		return piface.MergeOutput{}
-	}
-	sp, ok := mi.getPointer(in.Source)
-	if !ok {
-		return piface.MergeOutput{}
-	}
-	mi.mergePointer(dp, sp, mergeOptions{})
-	return piface.MergeOutput{Flags: piface.MergeComplete}
-}
-
-func (mi *MessageInfo) mergePointer(dst, src pointer, opts mergeOptions) {
-	mi.init()
-	if dst.IsNil() {
-		panic(fmt.Sprintf("invalid value: merging into nil message"))
-	}
-	if src.IsNil() {
-		return
-	}
-	for _, f := range mi.orderedCoderFields {
-		if f.funcs.merge == nil {
-			continue
-		}
-		sfptr := src.Apply(f.offset)
-		if f.isPointer && sfptr.Elem().IsNil() {
-			continue
-		}
-		f.funcs.merge(dst.Apply(f.offset), sfptr, f, opts)
-	}
-	if mi.extensionOffset.IsValid() {
-		sext := src.Apply(mi.extensionOffset).Extensions()
-		dext := dst.Apply(mi.extensionOffset).Extensions()
-		if *dext == nil {
-			*dext = make(map[int32]ExtensionField)
-		}
-		for num, sx := range *sext {
-			xt := sx.Type()
-			xi := getExtensionFieldInfo(xt)
-			if xi.funcs.merge == nil {
-				continue
-			}
-			dx := (*dext)[num]
-			var dv pref.Value
-			if dx.Type() == sx.Type() {
-				dv = dx.Value()
-			}
-			if !dv.IsValid() && xi.unmarshalNeedsValue {
-				dv = xt.New()
-			}
-			dv = xi.funcs.merge(dv, sx.Value(), opts)
-			dx.Set(sx.Type(), dv)
-			(*dext)[num] = dx
-		}
-	}
-	if mi.unknownOffset.IsValid() {
-		du := dst.Apply(mi.unknownOffset).Bytes()
-		su := src.Apply(mi.unknownOffset).Bytes()
-		if len(*su) > 0 {
-			*du = append(*du, *su...)
-		}
-	}
-}
-
-func mergeScalarValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	return src
-}
-
-func mergeBytesValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	return pref.ValueOfBytes(append(emptyBuf[:], src.Bytes()...))
-}
-
-func mergeListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	dstl := dst.List()
-	srcl := src.List()
-	for i, llen := 0, srcl.Len(); i < llen; i++ {
-		dstl.Append(srcl.Get(i))
-	}
-	return dst
-}
-
-func mergeBytesListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	dstl := dst.List()
-	srcl := src.List()
-	for i, llen := 0, srcl.Len(); i < llen; i++ {
-		sb := srcl.Get(i).Bytes()
-		db := append(emptyBuf[:], sb...)
-		dstl.Append(pref.ValueOfBytes(db))
-	}
-	return dst
-}
-
-func mergeMessageListValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	dstl := dst.List()
-	srcl := src.List()
-	for i, llen := 0, srcl.Len(); i < llen; i++ {
-		sm := srcl.Get(i).Message()
-		dm := proto.Clone(sm.Interface()).ProtoReflect()
-		dstl.Append(pref.ValueOfMessage(dm))
-	}
-	return dst
-}
-
-func mergeMessageValue(dst, src pref.Value, opts mergeOptions) pref.Value {
-	opts.Merge(dst.Message().Interface(), src.Message().Interface())
-	return dst
-}
-
-func mergeMessage(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
-	if f.mi != nil {
-		if dst.Elem().IsNil() {
-			dst.SetPointer(pointerOfValue(reflect.New(f.mi.GoReflectType.Elem())))
-		}
-		f.mi.mergePointer(dst.Elem(), src.Elem(), opts)
-	} else {
-		dm := dst.AsValueOf(f.ft).Elem()
-		sm := src.AsValueOf(f.ft).Elem()
-		if dm.IsNil() {
-			dm.Set(reflect.New(f.ft.Elem()))
-		}
-		opts.Merge(asMessage(dm), asMessage(sm))
-	}
-}
-
-func mergeMessageSlice(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
-	for _, sp := range src.PointerSlice() {
-		dm := reflect.New(f.ft.Elem().Elem())
-		if f.mi != nil {
-			f.mi.mergePointer(pointerOfValue(dm), sp, opts)
-		} else {
-			opts.Merge(asMessage(dm), asMessage(sp.AsValueOf(f.ft.Elem().Elem())))
-		}
-		dst.AppendPointerSlice(pointerOfValue(dm))
-	}
-}
-
-func mergeBytes(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Bytes() = append(emptyBuf[:], *src.Bytes()...)
-}
-
-func mergeBytesNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Bytes()
-	if len(v) > 0 {
-		*dst.Bytes() = append(emptyBuf[:], v...)
-	}
-}
-
-func mergeBytesSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.BytesSlice()
-	for _, v := range *src.BytesSlice() {
-		*ds = append(*ds, append(emptyBuf[:], v...))
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/merge_gen.go b/vendor/google.golang.org/protobuf/internal/impl/merge_gen.go
deleted file mode 100644
index 8816c27..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/merge_gen.go
+++ /dev/null
@@ -1,209 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package impl
-
-import ()
-
-func mergeBool(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Bool() = *src.Bool()
-}
-
-func mergeBoolNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Bool()
-	if v != false {
-		*dst.Bool() = v
-	}
-}
-
-func mergeBoolPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.BoolPtr()
-	if p != nil {
-		v := *p
-		*dst.BoolPtr() = &v
-	}
-}
-
-func mergeBoolSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.BoolSlice()
-	ss := src.BoolSlice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeInt32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Int32() = *src.Int32()
-}
-
-func mergeInt32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Int32()
-	if v != 0 {
-		*dst.Int32() = v
-	}
-}
-
-func mergeInt32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Int32Ptr()
-	if p != nil {
-		v := *p
-		*dst.Int32Ptr() = &v
-	}
-}
-
-func mergeInt32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Int32Slice()
-	ss := src.Int32Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeUint32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Uint32() = *src.Uint32()
-}
-
-func mergeUint32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Uint32()
-	if v != 0 {
-		*dst.Uint32() = v
-	}
-}
-
-func mergeUint32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Uint32Ptr()
-	if p != nil {
-		v := *p
-		*dst.Uint32Ptr() = &v
-	}
-}
-
-func mergeUint32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Uint32Slice()
-	ss := src.Uint32Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeInt64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Int64() = *src.Int64()
-}
-
-func mergeInt64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Int64()
-	if v != 0 {
-		*dst.Int64() = v
-	}
-}
-
-func mergeInt64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Int64Ptr()
-	if p != nil {
-		v := *p
-		*dst.Int64Ptr() = &v
-	}
-}
-
-func mergeInt64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Int64Slice()
-	ss := src.Int64Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeUint64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Uint64() = *src.Uint64()
-}
-
-func mergeUint64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Uint64()
-	if v != 0 {
-		*dst.Uint64() = v
-	}
-}
-
-func mergeUint64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Uint64Ptr()
-	if p != nil {
-		v := *p
-		*dst.Uint64Ptr() = &v
-	}
-}
-
-func mergeUint64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Uint64Slice()
-	ss := src.Uint64Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeFloat32(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Float32() = *src.Float32()
-}
-
-func mergeFloat32NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Float32()
-	if v != 0 {
-		*dst.Float32() = v
-	}
-}
-
-func mergeFloat32Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Float32Ptr()
-	if p != nil {
-		v := *p
-		*dst.Float32Ptr() = &v
-	}
-}
-
-func mergeFloat32Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Float32Slice()
-	ss := src.Float32Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeFloat64(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.Float64() = *src.Float64()
-}
-
-func mergeFloat64NoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.Float64()
-	if v != 0 {
-		*dst.Float64() = v
-	}
-}
-
-func mergeFloat64Ptr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.Float64Ptr()
-	if p != nil {
-		v := *p
-		*dst.Float64Ptr() = &v
-	}
-}
-
-func mergeFloat64Slice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.Float64Slice()
-	ss := src.Float64Slice()
-	*ds = append(*ds, *ss...)
-}
-
-func mergeString(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	*dst.String() = *src.String()
-}
-
-func mergeStringNoZero(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	v := *src.String()
-	if v != "" {
-		*dst.String() = v
-	}
-}
-
-func mergeStringPtr(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	p := *src.StringPtr()
-	if p != nil {
-		v := *p
-		*dst.StringPtr() = &v
-	}
-}
-
-func mergeStringSlice(dst, src pointer, _ *coderFieldInfo, _ mergeOptions) {
-	ds := dst.StringSlice()
-	ss := src.StringSlice()
-	*ds = append(*ds, *ss...)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message.go b/vendor/google.golang.org/protobuf/internal/impl/message.go
deleted file mode 100644
index 7dd994b..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/message.go
+++ /dev/null
@@ -1,215 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-
-	"google.golang.org/protobuf/internal/genname"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// MessageInfo provides protobuf related functionality for a given Go type
-// that represents a message. A given instance of MessageInfo is tied to
-// exactly one Go type, which must be a pointer to a struct type.
-//
-// The exported fields must be populated before any methods are called
-// and cannot be mutated after set.
-type MessageInfo struct {
-	// GoReflectType is the underlying message Go type and must be populated.
-	GoReflectType reflect.Type // pointer to struct
-
-	// Desc is the underlying message descriptor type and must be populated.
-	Desc pref.MessageDescriptor
-
-	// Exporter must be provided in a purego environment in order to provide
-	// access to unexported fields.
-	Exporter exporter
-
-	// OneofWrappers is list of pointers to oneof wrapper struct types.
-	OneofWrappers []interface{}
-
-	initMu   sync.Mutex // protects all unexported fields
-	initDone uint32
-
-	reflectMessageInfo // for reflection implementation
-	coderMessageInfo   // for fast-path method implementations
-}
-
-// exporter is a function that returns a reference to the ith field of v,
-// where v is a pointer to a struct. It returns nil if it does not support
-// exporting the requested field (e.g., already exported).
-type exporter func(v interface{}, i int) interface{}
-
-// getMessageInfo returns the MessageInfo for any message type that
-// is generated by our implementation of protoc-gen-go (for v2 and on).
-// If it is unable to obtain a MessageInfo, it returns nil.
-func getMessageInfo(mt reflect.Type) *MessageInfo {
-	m, ok := reflect.Zero(mt).Interface().(pref.ProtoMessage)
-	if !ok {
-		return nil
-	}
-	mr, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *MessageInfo })
-	if !ok {
-		return nil
-	}
-	return mr.ProtoMessageInfo()
-}
-
-func (mi *MessageInfo) init() {
-	// This function is called in the hot path. Inline the sync.Once logic,
-	// since allocating a closure for Once.Do is expensive.
-	// Keep init small to ensure that it can be inlined.
-	if atomic.LoadUint32(&mi.initDone) == 0 {
-		mi.initOnce()
-	}
-}
-
-func (mi *MessageInfo) initOnce() {
-	mi.initMu.Lock()
-	defer mi.initMu.Unlock()
-	if mi.initDone == 1 {
-		return
-	}
-
-	t := mi.GoReflectType
-	if t.Kind() != reflect.Ptr && t.Elem().Kind() != reflect.Struct {
-		panic(fmt.Sprintf("got %v, want *struct kind", t))
-	}
-	t = t.Elem()
-
-	si := mi.makeStructInfo(t)
-	mi.makeReflectFuncs(t, si)
-	mi.makeCoderMethods(t, si)
-
-	atomic.StoreUint32(&mi.initDone, 1)
-}
-
-// getPointer returns the pointer for a message, which should be of
-// the type of the MessageInfo. If the message is of a different type,
-// it returns ok==false.
-func (mi *MessageInfo) getPointer(m pref.Message) (p pointer, ok bool) {
-	switch m := m.(type) {
-	case *messageState:
-		return m.pointer(), m.messageInfo() == mi
-	case *messageReflectWrapper:
-		return m.pointer(), m.messageInfo() == mi
-	}
-	return pointer{}, false
-}
-
-type (
-	SizeCache       = int32
-	WeakFields      = map[int32]protoreflect.ProtoMessage
-	UnknownFields   = []byte
-	ExtensionFields = map[int32]ExtensionField
-)
-
-var (
-	sizecacheType       = reflect.TypeOf(SizeCache(0))
-	weakFieldsType      = reflect.TypeOf(WeakFields(nil))
-	unknownFieldsType   = reflect.TypeOf(UnknownFields(nil))
-	extensionFieldsType = reflect.TypeOf(ExtensionFields(nil))
-)
-
-type structInfo struct {
-	sizecacheOffset offset
-	weakOffset      offset
-	unknownOffset   offset
-	extensionOffset offset
-
-	fieldsByNumber        map[pref.FieldNumber]reflect.StructField
-	oneofsByName          map[pref.Name]reflect.StructField
-	oneofWrappersByType   map[reflect.Type]pref.FieldNumber
-	oneofWrappersByNumber map[pref.FieldNumber]reflect.Type
-}
-
-func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
-	si := structInfo{
-		sizecacheOffset: invalidOffset,
-		weakOffset:      invalidOffset,
-		unknownOffset:   invalidOffset,
-		extensionOffset: invalidOffset,
-
-		fieldsByNumber:        map[pref.FieldNumber]reflect.StructField{},
-		oneofsByName:          map[pref.Name]reflect.StructField{},
-		oneofWrappersByType:   map[reflect.Type]pref.FieldNumber{},
-		oneofWrappersByNumber: map[pref.FieldNumber]reflect.Type{},
-	}
-
-fieldLoop:
-	for i := 0; i < t.NumField(); i++ {
-		switch f := t.Field(i); f.Name {
-		case genname.SizeCache, genname.SizeCacheA:
-			if f.Type == sizecacheType {
-				si.sizecacheOffset = offsetOf(f, mi.Exporter)
-			}
-		case genname.WeakFields, genname.WeakFieldsA:
-			if f.Type == weakFieldsType {
-				si.weakOffset = offsetOf(f, mi.Exporter)
-			}
-		case genname.UnknownFields, genname.UnknownFieldsA:
-			if f.Type == unknownFieldsType {
-				si.unknownOffset = offsetOf(f, mi.Exporter)
-			}
-		case genname.ExtensionFields, genname.ExtensionFieldsA, genname.ExtensionFieldsB:
-			if f.Type == extensionFieldsType {
-				si.extensionOffset = offsetOf(f, mi.Exporter)
-			}
-		default:
-			for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
-				if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
-					n, _ := strconv.ParseUint(s, 10, 64)
-					si.fieldsByNumber[pref.FieldNumber(n)] = f
-					continue fieldLoop
-				}
-			}
-			if s := f.Tag.Get("protobuf_oneof"); len(s) > 0 {
-				si.oneofsByName[pref.Name(s)] = f
-				continue fieldLoop
-			}
-		}
-	}
-
-	// Derive a mapping of oneof wrappers to fields.
-	oneofWrappers := mi.OneofWrappers
-	for _, method := range []string{"XXX_OneofFuncs", "XXX_OneofWrappers"} {
-		if fn, ok := reflect.PtrTo(t).MethodByName(method); ok {
-			for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
-				if vs, ok := v.Interface().([]interface{}); ok {
-					oneofWrappers = vs
-				}
-			}
-		}
-	}
-	for _, v := range oneofWrappers {
-		tf := reflect.TypeOf(v).Elem()
-		f := tf.Field(0)
-		for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
-			if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
-				n, _ := strconv.ParseUint(s, 10, 64)
-				si.oneofWrappersByType[tf] = pref.FieldNumber(n)
-				si.oneofWrappersByNumber[pref.FieldNumber(n)] = tf
-				break
-			}
-		}
-	}
-
-	return si
-}
-
-func (mi *MessageInfo) New() protoreflect.Message {
-	return mi.MessageOf(reflect.New(mi.GoReflectType.Elem()).Interface())
-}
-func (mi *MessageInfo) Zero() protoreflect.Message {
-	return mi.MessageOf(reflect.Zero(mi.GoReflectType).Interface())
-}
-func (mi *MessageInfo) Descriptor() protoreflect.MessageDescriptor { return mi.Desc }
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go
deleted file mode 100644
index 0f4b8db..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go
+++ /dev/null
@@ -1,364 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-
-	"google.golang.org/protobuf/internal/pragma"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type reflectMessageInfo struct {
-	fields map[pref.FieldNumber]*fieldInfo
-	oneofs map[pref.Name]*oneofInfo
-
-	// denseFields is a subset of fields where:
-	//	0 < fieldDesc.Number() < len(denseFields)
-	// It provides faster access to the fieldInfo, but may be incomplete.
-	denseFields []*fieldInfo
-
-	// rangeInfos is a list of all fields (not belonging to a oneof) and oneofs.
-	rangeInfos []interface{} // either *fieldInfo or *oneofInfo
-
-	getUnknown   func(pointer) pref.RawFields
-	setUnknown   func(pointer, pref.RawFields)
-	extensionMap func(pointer) *extensionMap
-
-	nilMessage atomicNilMessage
-}
-
-// makeReflectFuncs generates the set of functions to support reflection.
-func (mi *MessageInfo) makeReflectFuncs(t reflect.Type, si structInfo) {
-	mi.makeKnownFieldsFunc(si)
-	mi.makeUnknownFieldsFunc(t, si)
-	mi.makeExtensionFieldsFunc(t, si)
-}
-
-// makeKnownFieldsFunc generates functions for operations that can be performed
-// on each protobuf message field. It takes in a reflect.Type representing the
-// Go struct and matches message fields with struct fields.
-//
-// This code assumes that the struct is well-formed and panics if there are
-// any discrepancies.
-func (mi *MessageInfo) makeKnownFieldsFunc(si structInfo) {
-	mi.fields = map[pref.FieldNumber]*fieldInfo{}
-	md := mi.Desc
-	fds := md.Fields()
-	for i := 0; i < fds.Len(); i++ {
-		fd := fds.Get(i)
-		fs := si.fieldsByNumber[fd.Number()]
-		var fi fieldInfo
-		switch {
-		case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
-			fi = fieldInfoForOneof(fd, si.oneofsByName[fd.ContainingOneof().Name()], mi.Exporter, si.oneofWrappersByNumber[fd.Number()])
-		case fd.IsMap():
-			fi = fieldInfoForMap(fd, fs, mi.Exporter)
-		case fd.IsList():
-			fi = fieldInfoForList(fd, fs, mi.Exporter)
-		case fd.IsWeak():
-			fi = fieldInfoForWeakMessage(fd, si.weakOffset)
-		case fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind:
-			fi = fieldInfoForMessage(fd, fs, mi.Exporter)
-		default:
-			fi = fieldInfoForScalar(fd, fs, mi.Exporter)
-		}
-		mi.fields[fd.Number()] = &fi
-	}
-
-	mi.oneofs = map[pref.Name]*oneofInfo{}
-	for i := 0; i < md.Oneofs().Len(); i++ {
-		od := md.Oneofs().Get(i)
-		mi.oneofs[od.Name()] = makeOneofInfo(od, si, mi.Exporter)
-	}
-
-	mi.denseFields = make([]*fieldInfo, fds.Len()*2)
-	for i := 0; i < fds.Len(); i++ {
-		if fd := fds.Get(i); int(fd.Number()) < len(mi.denseFields) {
-			mi.denseFields[fd.Number()] = mi.fields[fd.Number()]
-		}
-	}
-
-	for i := 0; i < fds.Len(); {
-		fd := fds.Get(i)
-		if od := fd.ContainingOneof(); od != nil && !od.IsSynthetic() {
-			mi.rangeInfos = append(mi.rangeInfos, mi.oneofs[od.Name()])
-			i += od.Fields().Len()
-		} else {
-			mi.rangeInfos = append(mi.rangeInfos, mi.fields[fd.Number()])
-			i++
-		}
-	}
-}
-
-func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
-	mi.getUnknown = func(pointer) pref.RawFields { return nil }
-	mi.setUnknown = func(pointer, pref.RawFields) { return }
-	if si.unknownOffset.IsValid() {
-		mi.getUnknown = func(p pointer) pref.RawFields {
-			if p.IsNil() {
-				return nil
-			}
-			rv := p.Apply(si.unknownOffset).AsValueOf(unknownFieldsType)
-			return pref.RawFields(*rv.Interface().(*[]byte))
-		}
-		mi.setUnknown = func(p pointer, b pref.RawFields) {
-			if p.IsNil() {
-				panic("invalid SetUnknown on nil Message")
-			}
-			rv := p.Apply(si.unknownOffset).AsValueOf(unknownFieldsType)
-			*rv.Interface().(*[]byte) = []byte(b)
-		}
-	} else {
-		mi.getUnknown = func(pointer) pref.RawFields {
-			return nil
-		}
-		mi.setUnknown = func(p pointer, _ pref.RawFields) {
-			if p.IsNil() {
-				panic("invalid SetUnknown on nil Message")
-			}
-		}
-	}
-}
-
-func (mi *MessageInfo) makeExtensionFieldsFunc(t reflect.Type, si structInfo) {
-	if si.extensionOffset.IsValid() {
-		mi.extensionMap = func(p pointer) *extensionMap {
-			if p.IsNil() {
-				return (*extensionMap)(nil)
-			}
-			v := p.Apply(si.extensionOffset).AsValueOf(extensionFieldsType)
-			return (*extensionMap)(v.Interface().(*map[int32]ExtensionField))
-		}
-	} else {
-		mi.extensionMap = func(pointer) *extensionMap {
-			return (*extensionMap)(nil)
-		}
-	}
-}
-
-type extensionMap map[int32]ExtensionField
-
-func (m *extensionMap) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
-	if m != nil {
-		for _, x := range *m {
-			xd := x.Type().TypeDescriptor()
-			v := x.Value()
-			if xd.IsList() && v.List().Len() == 0 {
-				continue
-			}
-			if !f(xd, v) {
-				return
-			}
-		}
-	}
-}
-func (m *extensionMap) Has(xt pref.ExtensionType) (ok bool) {
-	if m == nil {
-		return false
-	}
-	xd := xt.TypeDescriptor()
-	x, ok := (*m)[int32(xd.Number())]
-	if !ok {
-		return false
-	}
-	switch {
-	case xd.IsList():
-		return x.Value().List().Len() > 0
-	case xd.IsMap():
-		return x.Value().Map().Len() > 0
-	case xd.Message() != nil:
-		return x.Value().Message().IsValid()
-	}
-	return true
-}
-func (m *extensionMap) Clear(xt pref.ExtensionType) {
-	delete(*m, int32(xt.TypeDescriptor().Number()))
-}
-func (m *extensionMap) Get(xt pref.ExtensionType) pref.Value {
-	xd := xt.TypeDescriptor()
-	if m != nil {
-		if x, ok := (*m)[int32(xd.Number())]; ok {
-			return x.Value()
-		}
-	}
-	return xt.Zero()
-}
-func (m *extensionMap) Set(xt pref.ExtensionType, v pref.Value) {
-	xd := xt.TypeDescriptor()
-	isValid := true
-	switch {
-	case !xt.IsValidValue(v):
-		isValid = false
-	case xd.IsList():
-		isValid = v.List().IsValid()
-	case xd.IsMap():
-		isValid = v.Map().IsValid()
-	case xd.Message() != nil:
-		isValid = v.Message().IsValid()
-	}
-	if !isValid {
-		panic(fmt.Sprintf("%v: assigning invalid value", xt.TypeDescriptor().FullName()))
-	}
-
-	if *m == nil {
-		*m = make(map[int32]ExtensionField)
-	}
-	var x ExtensionField
-	x.Set(xt, v)
-	(*m)[int32(xd.Number())] = x
-}
-func (m *extensionMap) Mutable(xt pref.ExtensionType) pref.Value {
-	xd := xt.TypeDescriptor()
-	if xd.Kind() != pref.MessageKind && xd.Kind() != pref.GroupKind && !xd.IsList() && !xd.IsMap() {
-		panic("invalid Mutable on field with non-composite type")
-	}
-	if x, ok := (*m)[int32(xd.Number())]; ok {
-		return x.Value()
-	}
-	v := xt.New()
-	m.Set(xt, v)
-	return v
-}
-
-// MessageState is a data structure that is nested as the first field in a
-// concrete message. It provides a way to implement the ProtoReflect method
-// in an allocation-free way without needing to have a shadow Go type generated
-// for every message type. This technique only works using unsafe.
-//
-//
-// Example generated code:
-//
-//	type M struct {
-//		state protoimpl.MessageState
-//
-//		Field1 int32
-//		Field2 string
-//		Field3 *BarMessage
-//		...
-//	}
-//
-//	func (m *M) ProtoReflect() protoreflect.Message {
-//		mi := &file_fizz_buzz_proto_msgInfos[5]
-//		if protoimpl.UnsafeEnabled && m != nil {
-//			ms := protoimpl.X.MessageStateOf(Pointer(m))
-//			if ms.LoadMessageInfo() == nil {
-//				ms.StoreMessageInfo(mi)
-//			}
-//			return ms
-//		}
-//		return mi.MessageOf(m)
-//	}
-//
-// The MessageState type holds a *MessageInfo, which must be atomically set to
-// the message info associated with a given message instance.
-// By unsafely converting a *M into a *MessageState, the MessageState object
-// has access to all the information needed to implement protobuf reflection.
-// It has access to the message info as its first field, and a pointer to the
-// MessageState is identical to a pointer to the concrete message value.
-//
-//
-// Requirements:
-//	• The type M must implement protoreflect.ProtoMessage.
-//	• The address of m must not be nil.
-//	• The address of m and the address of m.state must be equal,
-//	even though they are different Go types.
-type MessageState struct {
-	pragma.NoUnkeyedLiterals
-	pragma.DoNotCompare
-	pragma.DoNotCopy
-
-	atomicMessageInfo *MessageInfo
-}
-
-type messageState MessageState
-
-var (
-	_ pref.Message = (*messageState)(nil)
-	_ unwrapper    = (*messageState)(nil)
-)
-
-// messageDataType is a tuple of a pointer to the message data and
-// a pointer to the message type. It is a generalized way of providing a
-// reflective view over a message instance. The disadvantage of this approach
-// is the need to allocate this tuple of 16B.
-type messageDataType struct {
-	p  pointer
-	mi *MessageInfo
-}
-
-type (
-	messageReflectWrapper messageDataType
-	messageIfaceWrapper   messageDataType
-)
-
-var (
-	_ pref.Message      = (*messageReflectWrapper)(nil)
-	_ unwrapper         = (*messageReflectWrapper)(nil)
-	_ pref.ProtoMessage = (*messageIfaceWrapper)(nil)
-	_ unwrapper         = (*messageIfaceWrapper)(nil)
-)
-
-// MessageOf returns a reflective view over a message. The input must be a
-// pointer to a named Go struct. If the provided type has a ProtoReflect method,
-// it must be implemented by calling this method.
-func (mi *MessageInfo) MessageOf(m interface{}) pref.Message {
-	// TODO: Switch the input to be an opaque Pointer.
-	if reflect.TypeOf(m) != mi.GoReflectType {
-		panic(fmt.Sprintf("type mismatch: got %T, want %v", m, mi.GoReflectType))
-	}
-	p := pointerOfIface(m)
-	if p.IsNil() {
-		return mi.nilMessage.Init(mi)
-	}
-	return &messageReflectWrapper{p, mi}
-}
-
-func (m *messageReflectWrapper) pointer() pointer          { return m.p }
-func (m *messageReflectWrapper) messageInfo() *MessageInfo { return m.mi }
-
-func (m *messageIfaceWrapper) ProtoReflect() pref.Message {
-	return (*messageReflectWrapper)(m)
-}
-func (m *messageIfaceWrapper) protoUnwrap() interface{} {
-	return m.p.AsIfaceOf(m.mi.GoReflectType.Elem())
-}
-
-// checkField verifies that the provided field descriptor is valid.
-// Exactly one of the returned values is populated.
-func (mi *MessageInfo) checkField(fd pref.FieldDescriptor) (*fieldInfo, pref.ExtensionType) {
-	var fi *fieldInfo
-	if n := fd.Number(); 0 < n && int(n) < len(mi.denseFields) {
-		fi = mi.denseFields[n]
-	} else {
-		fi = mi.fields[n]
-	}
-	if fi != nil {
-		if fi.fieldDesc != fd {
-			if got, want := fd.FullName(), fi.fieldDesc.FullName(); got != want {
-				panic(fmt.Sprintf("mismatching field: got %v, want %v", got, want))
-			}
-			panic(fmt.Sprintf("mismatching field: %v", fd.FullName()))
-		}
-		return fi, nil
-	}
-
-	if fd.IsExtension() {
-		if got, want := fd.ContainingMessage().FullName(), mi.Desc.FullName(); got != want {
-			// TODO: Should this be exact containing message descriptor match?
-			panic(fmt.Sprintf("extension %v has mismatching containing message: got %v, want %v", fd.FullName(), got, want))
-		}
-		if !mi.Desc.ExtensionRanges().Has(fd.Number()) {
-			panic(fmt.Sprintf("extension %v extends %v outside the extension range", fd.FullName(), mi.Desc.FullName()))
-		}
-		xtd, ok := fd.(pref.ExtensionTypeDescriptor)
-		if !ok {
-			panic(fmt.Sprintf("extension %v does not implement protoreflect.ExtensionTypeDescriptor", fd.FullName()))
-		}
-		return nil, xtd.Type()
-	}
-	panic(fmt.Sprintf("field %v is invalid", fd.FullName()))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_field.go b/vendor/google.golang.org/protobuf/internal/impl/message_reflect_field.go
deleted file mode 100644
index 23124a8..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_field.go
+++ /dev/null
@@ -1,466 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"math"
-	"reflect"
-	"sync"
-
-	"google.golang.org/protobuf/internal/flags"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-type fieldInfo struct {
-	fieldDesc pref.FieldDescriptor
-
-	// These fields are used for protobuf reflection support.
-	has        func(pointer) bool
-	clear      func(pointer)
-	get        func(pointer) pref.Value
-	set        func(pointer, pref.Value)
-	mutable    func(pointer) pref.Value
-	newMessage func() pref.Message
-	newField   func() pref.Value
-}
-
-func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
-	ft := fs.Type
-	if ft.Kind() != reflect.Interface {
-		panic(fmt.Sprintf("field %v has invalid type: got %v, want interface kind", fd.FullName(), ft))
-	}
-	if ot.Kind() != reflect.Struct {
-		panic(fmt.Sprintf("field %v has invalid type: got %v, want struct kind", fd.FullName(), ot))
-	}
-	if !reflect.PtrTo(ot).Implements(ft) {
-		panic(fmt.Sprintf("field %v has invalid type: %v does not implement %v", fd.FullName(), ot, ft))
-	}
-	conv := NewConverter(ot.Field(0).Type, fd)
-	isMessage := fd.Message() != nil
-
-	// TODO: Implement unsafe fast path?
-	fieldOffset := offsetOf(fs, x)
-	return fieldInfo{
-		// NOTE: The logic below intentionally assumes that oneof fields are
-		// well-formatted. That is, the oneof interface never contains a
-		// typed nil pointer to one of the wrapper structs.
-
-		fieldDesc: fd,
-		has: func(p pointer) bool {
-			if p.IsNil() {
-				return false
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
-				return false
-			}
-			return true
-		},
-		clear: func(p pointer) {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if rv.IsNil() || rv.Elem().Type().Elem() != ot {
-				// NOTE: We intentionally don't check for rv.Elem().IsNil()
-				// so that (*OneofWrapperType)(nil) gets cleared to nil.
-				return
-			}
-			rv.Set(reflect.Zero(rv.Type()))
-		},
-		get: func(p pointer) pref.Value {
-			if p.IsNil() {
-				return conv.Zero()
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
-				return conv.Zero()
-			}
-			rv = rv.Elem().Elem().Field(0)
-			return conv.PBValueOf(rv)
-		},
-		set: func(p pointer, v pref.Value) {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
-				rv.Set(reflect.New(ot))
-			}
-			rv = rv.Elem().Elem().Field(0)
-			rv.Set(conv.GoValueOf(v))
-		},
-		mutable: func(p pointer) pref.Value {
-			if !isMessage {
-				panic(fmt.Sprintf("field %v with invalid Mutable call on field with non-composite type", fd.FullName()))
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
-				rv.Set(reflect.New(ot))
-			}
-			rv = rv.Elem().Elem().Field(0)
-			if rv.IsNil() {
-				rv.Set(conv.GoValueOf(pref.ValueOfMessage(conv.New().Message())))
-			}
-			return conv.PBValueOf(rv)
-		},
-		newMessage: func() pref.Message {
-			return conv.New().Message()
-		},
-		newField: func() pref.Value {
-			return conv.New()
-		},
-	}
-}
-
-func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
-	ft := fs.Type
-	if ft.Kind() != reflect.Map {
-		panic(fmt.Sprintf("field %v has invalid type: got %v, want map kind", fd.FullName(), ft))
-	}
-	conv := NewConverter(ft, fd)
-
-	// TODO: Implement unsafe fast path?
-	fieldOffset := offsetOf(fs, x)
-	return fieldInfo{
-		fieldDesc: fd,
-		has: func(p pointer) bool {
-			if p.IsNil() {
-				return false
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			return rv.Len() > 0
-		},
-		clear: func(p pointer) {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			rv.Set(reflect.Zero(rv.Type()))
-		},
-		get: func(p pointer) pref.Value {
-			if p.IsNil() {
-				return conv.Zero()
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if rv.Len() == 0 {
-				return conv.Zero()
-			}
-			return conv.PBValueOf(rv)
-		},
-		set: func(p pointer, v pref.Value) {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			pv := conv.GoValueOf(v)
-			if pv.IsNil() {
-				panic(fmt.Sprintf("map field %v cannot be set with read-only value", fd.FullName()))
-			}
-			rv.Set(pv)
-		},
-		mutable: func(p pointer) pref.Value {
-			v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if v.IsNil() {
-				v.Set(reflect.MakeMap(fs.Type))
-			}
-			return conv.PBValueOf(v)
-		},
-		newField: func() pref.Value {
-			return conv.New()
-		},
-	}
-}
-
-func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
-	ft := fs.Type
-	if ft.Kind() != reflect.Slice {
-		panic(fmt.Sprintf("field %v has invalid type: got %v, want slice kind", fd.FullName(), ft))
-	}
-	conv := NewConverter(reflect.PtrTo(ft), fd)
-
-	// TODO: Implement unsafe fast path?
-	fieldOffset := offsetOf(fs, x)
-	return fieldInfo{
-		fieldDesc: fd,
-		has: func(p pointer) bool {
-			if p.IsNil() {
-				return false
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			return rv.Len() > 0
-		},
-		clear: func(p pointer) {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			rv.Set(reflect.Zero(rv.Type()))
-		},
-		get: func(p pointer) pref.Value {
-			if p.IsNil() {
-				return conv.Zero()
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type)
-			if rv.Elem().Len() == 0 {
-				return conv.Zero()
-			}
-			return conv.PBValueOf(rv)
-		},
-		set: func(p pointer, v pref.Value) {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			pv := conv.GoValueOf(v)
-			if pv.IsNil() {
-				panic(fmt.Sprintf("list field %v cannot be set with read-only value", fd.FullName()))
-			}
-			rv.Set(pv.Elem())
-		},
-		mutable: func(p pointer) pref.Value {
-			v := p.Apply(fieldOffset).AsValueOf(fs.Type)
-			return conv.PBValueOf(v)
-		},
-		newField: func() pref.Value {
-			return conv.New()
-		},
-	}
-}
-
-var (
-	nilBytes   = reflect.ValueOf([]byte(nil))
-	emptyBytes = reflect.ValueOf([]byte{})
-)
-
-func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
-	ft := fs.Type
-	nullable := fd.HasPresence()
-	isBytes := ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8
-	if nullable {
-		if ft.Kind() != reflect.Ptr && ft.Kind() != reflect.Slice {
-			panic(fmt.Sprintf("field %v has invalid type: got %v, want pointer", fd.FullName(), ft))
-		}
-		if ft.Kind() == reflect.Ptr {
-			ft = ft.Elem()
-		}
-	}
-	conv := NewConverter(ft, fd)
-
-	// TODO: Implement unsafe fast path?
-	fieldOffset := offsetOf(fs, x)
-	return fieldInfo{
-		fieldDesc: fd,
-		has: func(p pointer) bool {
-			if p.IsNil() {
-				return false
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if nullable {
-				return !rv.IsNil()
-			}
-			switch rv.Kind() {
-			case reflect.Bool:
-				return rv.Bool()
-			case reflect.Int32, reflect.Int64:
-				return rv.Int() != 0
-			case reflect.Uint32, reflect.Uint64:
-				return rv.Uint() != 0
-			case reflect.Float32, reflect.Float64:
-				return rv.Float() != 0 || math.Signbit(rv.Float())
-			case reflect.String, reflect.Slice:
-				return rv.Len() > 0
-			default:
-				panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen
-			}
-		},
-		clear: func(p pointer) {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			rv.Set(reflect.Zero(rv.Type()))
-		},
-		get: func(p pointer) pref.Value {
-			if p.IsNil() {
-				return conv.Zero()
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if nullable {
-				if rv.IsNil() {
-					return conv.Zero()
-				}
-				if rv.Kind() == reflect.Ptr {
-					rv = rv.Elem()
-				}
-			}
-			return conv.PBValueOf(rv)
-		},
-		set: func(p pointer, v pref.Value) {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if nullable && rv.Kind() == reflect.Ptr {
-				if rv.IsNil() {
-					rv.Set(reflect.New(ft))
-				}
-				rv = rv.Elem()
-			}
-			rv.Set(conv.GoValueOf(v))
-			if isBytes && rv.Len() == 0 {
-				if nullable {
-					rv.Set(emptyBytes) // preserve presence
-				} else {
-					rv.Set(nilBytes) // do not preserve presence
-				}
-			}
-		},
-		newField: func() pref.Value {
-			return conv.New()
-		},
-	}
-}
-
-func fieldInfoForWeakMessage(fd pref.FieldDescriptor, weakOffset offset) fieldInfo {
-	if !flags.ProtoLegacy {
-		panic("no support for proto1 weak fields")
-	}
-
-	var once sync.Once
-	var messageType pref.MessageType
-	lazyInit := func() {
-		once.Do(func() {
-			messageName := fd.Message().FullName()
-			messageType, _ = preg.GlobalTypes.FindMessageByName(messageName)
-			if messageType == nil {
-				panic(fmt.Sprintf("weak message %v for field %v is not linked in", messageName, fd.FullName()))
-			}
-		})
-	}
-
-	num := fd.Number()
-	return fieldInfo{
-		fieldDesc: fd,
-		has: func(p pointer) bool {
-			if p.IsNil() {
-				return false
-			}
-			_, ok := p.Apply(weakOffset).WeakFields().get(num)
-			return ok
-		},
-		clear: func(p pointer) {
-			p.Apply(weakOffset).WeakFields().clear(num)
-		},
-		get: func(p pointer) pref.Value {
-			lazyInit()
-			if p.IsNil() {
-				return pref.ValueOfMessage(messageType.Zero())
-			}
-			m, ok := p.Apply(weakOffset).WeakFields().get(num)
-			if !ok {
-				return pref.ValueOfMessage(messageType.Zero())
-			}
-			return pref.ValueOfMessage(m.ProtoReflect())
-		},
-		set: func(p pointer, v pref.Value) {
-			lazyInit()
-			m := v.Message()
-			if m.Descriptor() != messageType.Descriptor() {
-				if got, want := m.Descriptor().FullName(), messageType.Descriptor().FullName(); got != want {
-					panic(fmt.Sprintf("field %v has mismatching message descriptor: got %v, want %v", fd.FullName(), got, want))
-				}
-				panic(fmt.Sprintf("field %v has mismatching message descriptor: %v", fd.FullName(), m.Descriptor().FullName()))
-			}
-			p.Apply(weakOffset).WeakFields().set(num, m.Interface())
-		},
-		mutable: func(p pointer) pref.Value {
-			lazyInit()
-			fs := p.Apply(weakOffset).WeakFields()
-			m, ok := fs.get(num)
-			if !ok {
-				m = messageType.New().Interface()
-				fs.set(num, m)
-			}
-			return pref.ValueOfMessage(m.ProtoReflect())
-		},
-		newMessage: func() pref.Message {
-			lazyInit()
-			return messageType.New()
-		},
-		newField: func() pref.Value {
-			lazyInit()
-			return pref.ValueOfMessage(messageType.New())
-		},
-	}
-}
-
-func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
-	ft := fs.Type
-	conv := NewConverter(ft, fd)
-
-	// TODO: Implement unsafe fast path?
-	fieldOffset := offsetOf(fs, x)
-	return fieldInfo{
-		fieldDesc: fd,
-		has: func(p pointer) bool {
-			if p.IsNil() {
-				return false
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			return !rv.IsNil()
-		},
-		clear: func(p pointer) {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			rv.Set(reflect.Zero(rv.Type()))
-		},
-		get: func(p pointer) pref.Value {
-			if p.IsNil() {
-				return conv.Zero()
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			return conv.PBValueOf(rv)
-		},
-		set: func(p pointer, v pref.Value) {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			rv.Set(conv.GoValueOf(v))
-			if rv.IsNil() {
-				panic(fmt.Sprintf("field %v has invalid nil pointer", fd.FullName()))
-			}
-		},
-		mutable: func(p pointer) pref.Value {
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if rv.IsNil() {
-				rv.Set(conv.GoValueOf(conv.New()))
-			}
-			return conv.PBValueOf(rv)
-		},
-		newMessage: func() pref.Message {
-			return conv.New().Message()
-		},
-		newField: func() pref.Value {
-			return conv.New()
-		},
-	}
-}
-
-type oneofInfo struct {
-	oneofDesc pref.OneofDescriptor
-	which     func(pointer) pref.FieldNumber
-}
-
-func makeOneofInfo(od pref.OneofDescriptor, si structInfo, x exporter) *oneofInfo {
-	oi := &oneofInfo{oneofDesc: od}
-	if od.IsSynthetic() {
-		fs := si.fieldsByNumber[od.Fields().Get(0).Number()]
-		fieldOffset := offsetOf(fs, x)
-		oi.which = func(p pointer) pref.FieldNumber {
-			if p.IsNil() {
-				return 0
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if rv.IsNil() { // valid on either *T or []byte
-				return 0
-			}
-			return od.Fields().Get(0).Number()
-		}
-	} else {
-		fs := si.oneofsByName[od.Name()]
-		fieldOffset := offsetOf(fs, x)
-		oi.which = func(p pointer) pref.FieldNumber {
-			if p.IsNil() {
-				return 0
-			}
-			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
-			if rv.IsNil() {
-				return 0
-			}
-			rv = rv.Elem()
-			if rv.IsNil() {
-				return 0
-			}
-			return si.oneofWrappersByType[rv.Type().Elem()]
-		}
-	}
-	return oi
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go b/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go
deleted file mode 100644
index 741d6e5..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go
+++ /dev/null
@@ -1,249 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package impl
-
-import (
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoiface"
-)
-
-func (m *messageState) Descriptor() protoreflect.MessageDescriptor {
-	return m.messageInfo().Desc
-}
-func (m *messageState) Type() protoreflect.MessageType {
-	return m.messageInfo()
-}
-func (m *messageState) New() protoreflect.Message {
-	return m.messageInfo().New()
-}
-func (m *messageState) Interface() protoreflect.ProtoMessage {
-	return m.protoUnwrap().(protoreflect.ProtoMessage)
-}
-func (m *messageState) protoUnwrap() interface{} {
-	return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem())
-}
-func (m *messageState) ProtoMethods() *protoiface.Methods {
-	m.messageInfo().init()
-	return &m.messageInfo().methods
-}
-
-// ProtoMessageInfo is a pseudo-internal API for allowing the v1 code
-// to be able to retrieve a v2 MessageInfo struct.
-//
-// WARNING: This method is exempt from the compatibility promise and
-// may be removed in the future without warning.
-func (m *messageState) ProtoMessageInfo() *MessageInfo {
-	return m.messageInfo()
-}
-
-func (m *messageState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	m.messageInfo().init()
-	for _, ri := range m.messageInfo().rangeInfos {
-		switch ri := ri.(type) {
-		case *fieldInfo:
-			if ri.has(m.pointer()) {
-				if !f(ri.fieldDesc, ri.get(m.pointer())) {
-					return
-				}
-			}
-		case *oneofInfo:
-			if n := ri.which(m.pointer()); n > 0 {
-				fi := m.messageInfo().fields[n]
-				if !f(fi.fieldDesc, fi.get(m.pointer())) {
-					return
-				}
-			}
-		}
-	}
-	m.messageInfo().extensionMap(m.pointer()).Range(f)
-}
-func (m *messageState) Has(fd protoreflect.FieldDescriptor) bool {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		return fi.has(m.pointer())
-	} else {
-		return m.messageInfo().extensionMap(m.pointer()).Has(xt)
-	}
-}
-func (m *messageState) Clear(fd protoreflect.FieldDescriptor) {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		fi.clear(m.pointer())
-	} else {
-		m.messageInfo().extensionMap(m.pointer()).Clear(xt)
-	}
-}
-func (m *messageState) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		return fi.get(m.pointer())
-	} else {
-		return m.messageInfo().extensionMap(m.pointer()).Get(xt)
-	}
-}
-func (m *messageState) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		fi.set(m.pointer(), v)
-	} else {
-		m.messageInfo().extensionMap(m.pointer()).Set(xt, v)
-	}
-}
-func (m *messageState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		return fi.mutable(m.pointer())
-	} else {
-		return m.messageInfo().extensionMap(m.pointer()).Mutable(xt)
-	}
-}
-func (m *messageState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		return fi.newField()
-	} else {
-		return xt.New()
-	}
-}
-func (m *messageState) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
-	m.messageInfo().init()
-	if oi := m.messageInfo().oneofs[od.Name()]; oi != nil && oi.oneofDesc == od {
-		return od.Fields().ByNumber(oi.which(m.pointer()))
-	}
-	panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName()))
-}
-func (m *messageState) GetUnknown() protoreflect.RawFields {
-	m.messageInfo().init()
-	return m.messageInfo().getUnknown(m.pointer())
-}
-func (m *messageState) SetUnknown(b protoreflect.RawFields) {
-	m.messageInfo().init()
-	m.messageInfo().setUnknown(m.pointer(), b)
-}
-func (m *messageState) IsValid() bool {
-	return !m.pointer().IsNil()
-}
-
-func (m *messageReflectWrapper) Descriptor() protoreflect.MessageDescriptor {
-	return m.messageInfo().Desc
-}
-func (m *messageReflectWrapper) Type() protoreflect.MessageType {
-	return m.messageInfo()
-}
-func (m *messageReflectWrapper) New() protoreflect.Message {
-	return m.messageInfo().New()
-}
-func (m *messageReflectWrapper) Interface() protoreflect.ProtoMessage {
-	if m, ok := m.protoUnwrap().(protoreflect.ProtoMessage); ok {
-		return m
-	}
-	return (*messageIfaceWrapper)(m)
-}
-func (m *messageReflectWrapper) protoUnwrap() interface{} {
-	return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem())
-}
-func (m *messageReflectWrapper) ProtoMethods() *protoiface.Methods {
-	m.messageInfo().init()
-	return &m.messageInfo().methods
-}
-
-// ProtoMessageInfo is a pseudo-internal API for allowing the v1 code
-// to be able to retrieve a v2 MessageInfo struct.
-//
-// WARNING: This method is exempt from the compatibility promise and
-// may be removed in the future without warning.
-func (m *messageReflectWrapper) ProtoMessageInfo() *MessageInfo {
-	return m.messageInfo()
-}
-
-func (m *messageReflectWrapper) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	m.messageInfo().init()
-	for _, ri := range m.messageInfo().rangeInfos {
-		switch ri := ri.(type) {
-		case *fieldInfo:
-			if ri.has(m.pointer()) {
-				if !f(ri.fieldDesc, ri.get(m.pointer())) {
-					return
-				}
-			}
-		case *oneofInfo:
-			if n := ri.which(m.pointer()); n > 0 {
-				fi := m.messageInfo().fields[n]
-				if !f(fi.fieldDesc, fi.get(m.pointer())) {
-					return
-				}
-			}
-		}
-	}
-	m.messageInfo().extensionMap(m.pointer()).Range(f)
-}
-func (m *messageReflectWrapper) Has(fd protoreflect.FieldDescriptor) bool {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		return fi.has(m.pointer())
-	} else {
-		return m.messageInfo().extensionMap(m.pointer()).Has(xt)
-	}
-}
-func (m *messageReflectWrapper) Clear(fd protoreflect.FieldDescriptor) {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		fi.clear(m.pointer())
-	} else {
-		m.messageInfo().extensionMap(m.pointer()).Clear(xt)
-	}
-}
-func (m *messageReflectWrapper) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		return fi.get(m.pointer())
-	} else {
-		return m.messageInfo().extensionMap(m.pointer()).Get(xt)
-	}
-}
-func (m *messageReflectWrapper) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		fi.set(m.pointer(), v)
-	} else {
-		m.messageInfo().extensionMap(m.pointer()).Set(xt, v)
-	}
-}
-func (m *messageReflectWrapper) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		return fi.mutable(m.pointer())
-	} else {
-		return m.messageInfo().extensionMap(m.pointer()).Mutable(xt)
-	}
-}
-func (m *messageReflectWrapper) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
-	m.messageInfo().init()
-	if fi, xt := m.messageInfo().checkField(fd); fi != nil {
-		return fi.newField()
-	} else {
-		return xt.New()
-	}
-}
-func (m *messageReflectWrapper) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
-	m.messageInfo().init()
-	if oi := m.messageInfo().oneofs[od.Name()]; oi != nil && oi.oneofDesc == od {
-		return od.Fields().ByNumber(oi.which(m.pointer()))
-	}
-	panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName()))
-}
-func (m *messageReflectWrapper) GetUnknown() protoreflect.RawFields {
-	m.messageInfo().init()
-	return m.messageInfo().getUnknown(m.pointer())
-}
-func (m *messageReflectWrapper) SetUnknown(b protoreflect.RawFields) {
-	m.messageInfo().init()
-	m.messageInfo().setUnknown(m.pointer(), b)
-}
-func (m *messageReflectWrapper) IsValid() bool {
-	return !m.pointer().IsNil()
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go b/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go
deleted file mode 100644
index 67b4ede..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build purego appengine
-
-package impl
-
-import (
-	"fmt"
-	"reflect"
-	"sync"
-)
-
-const UnsafeEnabled = false
-
-// Pointer is an opaque pointer type.
-type Pointer interface{}
-
-// offset represents the offset to a struct field, accessible from a pointer.
-// The offset is the field index into a struct.
-type offset struct {
-	index  int
-	export exporter
-}
-
-// offsetOf returns a field offset for the struct field.
-func offsetOf(f reflect.StructField, x exporter) offset {
-	if len(f.Index) != 1 {
-		panic("embedded structs are not supported")
-	}
-	if f.PkgPath == "" {
-		return offset{index: f.Index[0]} // field is already exported
-	}
-	if x == nil {
-		panic("exporter must be provided for unexported field")
-	}
-	return offset{index: f.Index[0], export: x}
-}
-
-// IsValid reports whether the offset is valid.
-func (f offset) IsValid() bool { return f.index >= 0 }
-
-// invalidOffset is an invalid field offset.
-var invalidOffset = offset{index: -1}
-
-// zeroOffset is a noop when calling pointer.Apply.
-var zeroOffset = offset{index: 0}
-
-// pointer is an abstract representation of a pointer to a struct or field.
-type pointer struct{ v reflect.Value }
-
-// pointerOf returns p as a pointer.
-func pointerOf(p Pointer) pointer {
-	return pointerOfIface(p)
-}
-
-// pointerOfValue returns v as a pointer.
-func pointerOfValue(v reflect.Value) pointer {
-	return pointer{v: v}
-}
-
-// pointerOfIface returns the pointer portion of an interface.
-func pointerOfIface(v interface{}) pointer {
-	return pointer{v: reflect.ValueOf(v)}
-}
-
-// IsNil reports whether the pointer is nil.
-func (p pointer) IsNil() bool {
-	return p.v.IsNil()
-}
-
-// Apply adds an offset to the pointer to derive a new pointer
-// to a specified field. The current pointer must be pointing at a struct.
-func (p pointer) Apply(f offset) pointer {
-	if f.export != nil {
-		if v := reflect.ValueOf(f.export(p.v.Interface(), f.index)); v.IsValid() {
-			return pointer{v: v}
-		}
-	}
-	return pointer{v: p.v.Elem().Field(f.index).Addr()}
-}
-
-// AsValueOf treats p as a pointer to an object of type t and returns the value.
-// It is equivalent to reflect.ValueOf(p.AsIfaceOf(t))
-func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
-	if got := p.v.Type().Elem(); got != t {
-		panic(fmt.Sprintf("invalid type: got %v, want %v", got, t))
-	}
-	return p.v
-}
-
-// AsIfaceOf treats p as a pointer to an object of type t and returns the value.
-// It is equivalent to p.AsValueOf(t).Interface()
-func (p pointer) AsIfaceOf(t reflect.Type) interface{} {
-	return p.AsValueOf(t).Interface()
-}
-
-func (p pointer) Bool() *bool              { return p.v.Interface().(*bool) }
-func (p pointer) BoolPtr() **bool          { return p.v.Interface().(**bool) }
-func (p pointer) BoolSlice() *[]bool       { return p.v.Interface().(*[]bool) }
-func (p pointer) Int32() *int32            { return p.v.Interface().(*int32) }
-func (p pointer) Int32Ptr() **int32        { return p.v.Interface().(**int32) }
-func (p pointer) Int32Slice() *[]int32     { return p.v.Interface().(*[]int32) }
-func (p pointer) Int64() *int64            { return p.v.Interface().(*int64) }
-func (p pointer) Int64Ptr() **int64        { return p.v.Interface().(**int64) }
-func (p pointer) Int64Slice() *[]int64     { return p.v.Interface().(*[]int64) }
-func (p pointer) Uint32() *uint32          { return p.v.Interface().(*uint32) }
-func (p pointer) Uint32Ptr() **uint32      { return p.v.Interface().(**uint32) }
-func (p pointer) Uint32Slice() *[]uint32   { return p.v.Interface().(*[]uint32) }
-func (p pointer) Uint64() *uint64          { return p.v.Interface().(*uint64) }
-func (p pointer) Uint64Ptr() **uint64      { return p.v.Interface().(**uint64) }
-func (p pointer) Uint64Slice() *[]uint64   { return p.v.Interface().(*[]uint64) }
-func (p pointer) Float32() *float32        { return p.v.Interface().(*float32) }
-func (p pointer) Float32Ptr() **float32    { return p.v.Interface().(**float32) }
-func (p pointer) Float32Slice() *[]float32 { return p.v.Interface().(*[]float32) }
-func (p pointer) Float64() *float64        { return p.v.Interface().(*float64) }
-func (p pointer) Float64Ptr() **float64    { return p.v.Interface().(**float64) }
-func (p pointer) Float64Slice() *[]float64 { return p.v.Interface().(*[]float64) }
-func (p pointer) String() *string          { return p.v.Interface().(*string) }
-func (p pointer) StringPtr() **string      { return p.v.Interface().(**string) }
-func (p pointer) StringSlice() *[]string   { return p.v.Interface().(*[]string) }
-func (p pointer) Bytes() *[]byte           { return p.v.Interface().(*[]byte) }
-func (p pointer) BytesSlice() *[][]byte    { return p.v.Interface().(*[][]byte) }
-func (p pointer) WeakFields() *weakFields  { return (*weakFields)(p.v.Interface().(*WeakFields)) }
-func (p pointer) Extensions() *map[int32]ExtensionField {
-	return p.v.Interface().(*map[int32]ExtensionField)
-}
-
-func (p pointer) Elem() pointer {
-	return pointer{v: p.v.Elem()}
-}
-
-// PointerSlice copies []*T from p as a new []pointer.
-// This behavior differs from the implementation in pointer_unsafe.go.
-func (p pointer) PointerSlice() []pointer {
-	// TODO: reconsider this
-	if p.v.IsNil() {
-		return nil
-	}
-	n := p.v.Elem().Len()
-	s := make([]pointer, n)
-	for i := 0; i < n; i++ {
-		s[i] = pointer{v: p.v.Elem().Index(i)}
-	}
-	return s
-}
-
-// AppendPointerSlice appends v to p, which must be a []*T.
-func (p pointer) AppendPointerSlice(v pointer) {
-	sp := p.v.Elem()
-	sp.Set(reflect.Append(sp, v.v))
-}
-
-// SetPointer sets *p to v.
-func (p pointer) SetPointer(v pointer) {
-	p.v.Elem().Set(v.v)
-}
-
-func (Export) MessageStateOf(p Pointer) *messageState     { panic("not supported") }
-func (ms *messageState) pointer() pointer                 { panic("not supported") }
-func (ms *messageState) messageInfo() *MessageInfo        { panic("not supported") }
-func (ms *messageState) LoadMessageInfo() *MessageInfo    { panic("not supported") }
-func (ms *messageState) StoreMessageInfo(mi *MessageInfo) { panic("not supported") }
-
-type atomicNilMessage struct {
-	once sync.Once
-	m    messageReflectWrapper
-}
-
-func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper {
-	m.once.Do(func() {
-		m.m.p = pointerOfIface(reflect.Zero(mi.GoReflectType).Interface())
-		m.m.mi = mi
-	})
-	return &m.m
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go b/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go
deleted file mode 100644
index 088aa85..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !purego,!appengine
-
-package impl
-
-import (
-	"reflect"
-	"sync/atomic"
-	"unsafe"
-)
-
-const UnsafeEnabled = true
-
-// Pointer is an opaque pointer type.
-type Pointer unsafe.Pointer
-
-// offset represents the offset to a struct field, accessible from a pointer.
-// The offset is the byte offset to the field from the start of the struct.
-type offset uintptr
-
-// offsetOf returns a field offset for the struct field.
-func offsetOf(f reflect.StructField, x exporter) offset {
-	return offset(f.Offset)
-}
-
-// IsValid reports whether the offset is valid.
-func (f offset) IsValid() bool { return f != invalidOffset }
-
-// invalidOffset is an invalid field offset.
-var invalidOffset = ^offset(0)
-
-// zeroOffset is a noop when calling pointer.Apply.
-var zeroOffset = offset(0)
-
-// pointer is a pointer to a message struct or field.
-type pointer struct{ p unsafe.Pointer }
-
-// pointerOf returns p as a pointer.
-func pointerOf(p Pointer) pointer {
-	return pointer{p: unsafe.Pointer(p)}
-}
-
-// pointerOfValue returns v as a pointer.
-func pointerOfValue(v reflect.Value) pointer {
-	return pointer{p: unsafe.Pointer(v.Pointer())}
-}
-
-// pointerOfIface returns the pointer portion of an interface.
-func pointerOfIface(v interface{}) pointer {
-	type ifaceHeader struct {
-		Type unsafe.Pointer
-		Data unsafe.Pointer
-	}
-	return pointer{p: (*ifaceHeader)(unsafe.Pointer(&v)).Data}
-}
-
-// IsNil reports whether the pointer is nil.
-func (p pointer) IsNil() bool {
-	return p.p == nil
-}
-
-// Apply adds an offset to the pointer to derive a new pointer
-// to a specified field. The pointer must be valid and pointing at a struct.
-func (p pointer) Apply(f offset) pointer {
-	if p.IsNil() {
-		panic("invalid nil pointer")
-	}
-	return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
-}
-
-// AsValueOf treats p as a pointer to an object of type t and returns the value.
-// It is equivalent to reflect.ValueOf(p.AsIfaceOf(t))
-func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
-	return reflect.NewAt(t, p.p)
-}
-
-// AsIfaceOf treats p as a pointer to an object of type t and returns the value.
-// It is equivalent to p.AsValueOf(t).Interface()
-func (p pointer) AsIfaceOf(t reflect.Type) interface{} {
-	// TODO: Use tricky unsafe magic to directly create ifaceHeader.
-	return p.AsValueOf(t).Interface()
-}
-
-func (p pointer) Bool() *bool                           { return (*bool)(p.p) }
-func (p pointer) BoolPtr() **bool                       { return (**bool)(p.p) }
-func (p pointer) BoolSlice() *[]bool                    { return (*[]bool)(p.p) }
-func (p pointer) Int32() *int32                         { return (*int32)(p.p) }
-func (p pointer) Int32Ptr() **int32                     { return (**int32)(p.p) }
-func (p pointer) Int32Slice() *[]int32                  { return (*[]int32)(p.p) }
-func (p pointer) Int64() *int64                         { return (*int64)(p.p) }
-func (p pointer) Int64Ptr() **int64                     { return (**int64)(p.p) }
-func (p pointer) Int64Slice() *[]int64                  { return (*[]int64)(p.p) }
-func (p pointer) Uint32() *uint32                       { return (*uint32)(p.p) }
-func (p pointer) Uint32Ptr() **uint32                   { return (**uint32)(p.p) }
-func (p pointer) Uint32Slice() *[]uint32                { return (*[]uint32)(p.p) }
-func (p pointer) Uint64() *uint64                       { return (*uint64)(p.p) }
-func (p pointer) Uint64Ptr() **uint64                   { return (**uint64)(p.p) }
-func (p pointer) Uint64Slice() *[]uint64                { return (*[]uint64)(p.p) }
-func (p pointer) Float32() *float32                     { return (*float32)(p.p) }
-func (p pointer) Float32Ptr() **float32                 { return (**float32)(p.p) }
-func (p pointer) Float32Slice() *[]float32              { return (*[]float32)(p.p) }
-func (p pointer) Float64() *float64                     { return (*float64)(p.p) }
-func (p pointer) Float64Ptr() **float64                 { return (**float64)(p.p) }
-func (p pointer) Float64Slice() *[]float64              { return (*[]float64)(p.p) }
-func (p pointer) String() *string                       { return (*string)(p.p) }
-func (p pointer) StringPtr() **string                   { return (**string)(p.p) }
-func (p pointer) StringSlice() *[]string                { return (*[]string)(p.p) }
-func (p pointer) Bytes() *[]byte                        { return (*[]byte)(p.p) }
-func (p pointer) BytesSlice() *[][]byte                 { return (*[][]byte)(p.p) }
-func (p pointer) WeakFields() *weakFields               { return (*weakFields)(p.p) }
-func (p pointer) Extensions() *map[int32]ExtensionField { return (*map[int32]ExtensionField)(p.p) }
-
-func (p pointer) Elem() pointer {
-	return pointer{p: *(*unsafe.Pointer)(p.p)}
-}
-
-// PointerSlice loads []*T from p as a []pointer.
-// The value returned is aliased with the original slice.
-// This behavior differs from the implementation in pointer_reflect.go.
-func (p pointer) PointerSlice() []pointer {
-	// Super-tricky - p should point to a []*T where T is a
-	// message type. We load it as []pointer.
-	return *(*[]pointer)(p.p)
-}
-
-// AppendPointerSlice appends v to p, which must be a []*T.
-func (p pointer) AppendPointerSlice(v pointer) {
-	*(*[]pointer)(p.p) = append(*(*[]pointer)(p.p), v)
-}
-
-// SetPointer sets *p to v.
-func (p pointer) SetPointer(v pointer) {
-	*(*unsafe.Pointer)(p.p) = (unsafe.Pointer)(v.p)
-}
-
-// Static check that MessageState does not exceed the size of a pointer.
-const _ = uint(unsafe.Sizeof(unsafe.Pointer(nil)) - unsafe.Sizeof(MessageState{}))
-
-func (Export) MessageStateOf(p Pointer) *messageState {
-	// Super-tricky - see documentation on MessageState.
-	return (*messageState)(unsafe.Pointer(p))
-}
-func (ms *messageState) pointer() pointer {
-	// Super-tricky - see documentation on MessageState.
-	return pointer{p: unsafe.Pointer(ms)}
-}
-func (ms *messageState) messageInfo() *MessageInfo {
-	mi := ms.LoadMessageInfo()
-	if mi == nil {
-		panic("invalid nil message info; this suggests memory corruption due to a race or shallow copy on the message struct")
-	}
-	return mi
-}
-func (ms *messageState) LoadMessageInfo() *MessageInfo {
-	return (*MessageInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo))))
-}
-func (ms *messageState) StoreMessageInfo(mi *MessageInfo) {
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo)), unsafe.Pointer(mi))
-}
-
-type atomicNilMessage struct{ p unsafe.Pointer } // p is a *messageReflectWrapper
-
-func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper {
-	if p := atomic.LoadPointer(&m.p); p != nil {
-		return (*messageReflectWrapper)(p)
-	}
-	w := &messageReflectWrapper{mi: mi}
-	atomic.CompareAndSwapPointer(&m.p, nil, (unsafe.Pointer)(w))
-	return (*messageReflectWrapper)(atomic.LoadPointer(&m.p))
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/validate.go b/vendor/google.golang.org/protobuf/internal/impl/validate.go
deleted file mode 100644
index 57de9cc..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/validate.go
+++ /dev/null
@@ -1,575 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-	"math"
-	"math/bits"
-	"reflect"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/flags"
-	"google.golang.org/protobuf/internal/strs"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	preg "google.golang.org/protobuf/reflect/protoregistry"
-	piface "google.golang.org/protobuf/runtime/protoiface"
-)
-
-// ValidationStatus is the result of validating the wire-format encoding of a message.
-type ValidationStatus int
-
-const (
-	// ValidationUnknown indicates that unmarshaling the message might succeed or fail.
-	// The validator was unable to render a judgement.
-	//
-	// The only causes of this status are an aberrant message type appearing somewhere
-	// in the message or a failure in the extension resolver.
-	ValidationUnknown ValidationStatus = iota + 1
-
-	// ValidationInvalid indicates that unmarshaling the message will fail.
-	ValidationInvalid
-
-	// ValidationValid indicates that unmarshaling the message will succeed.
-	ValidationValid
-)
-
-func (v ValidationStatus) String() string {
-	switch v {
-	case ValidationUnknown:
-		return "ValidationUnknown"
-	case ValidationInvalid:
-		return "ValidationInvalid"
-	case ValidationValid:
-		return "ValidationValid"
-	default:
-		return fmt.Sprintf("ValidationStatus(%d)", int(v))
-	}
-}
-
-// Validate determines whether the contents of the buffer are a valid wire encoding
-// of the message type.
-//
-// This function is exposed for testing.
-func Validate(mt pref.MessageType, in piface.UnmarshalInput) (out piface.UnmarshalOutput, _ ValidationStatus) {
-	mi, ok := mt.(*MessageInfo)
-	if !ok {
-		return out, ValidationUnknown
-	}
-	if in.Resolver == nil {
-		in.Resolver = preg.GlobalTypes
-	}
-	o, st := mi.validate(in.Buf, 0, unmarshalOptions{
-		flags:    in.Flags,
-		resolver: in.Resolver,
-	})
-	if o.initialized {
-		out.Flags |= piface.UnmarshalInitialized
-	}
-	return out, st
-}
-
-type validationInfo struct {
-	mi               *MessageInfo
-	typ              validationType
-	keyType, valType validationType
-
-	// For non-required fields, requiredBit is 0.
-	//
-	// For required fields, requiredBit's nth bit is set, where n is a
-	// unique index in the range [0, MessageInfo.numRequiredFields).
-	//
-	// If there are more than 64 required fields, requiredBit is 0.
-	requiredBit uint64
-}
-
-type validationType uint8
-
-const (
-	validationTypeOther validationType = iota
-	validationTypeMessage
-	validationTypeGroup
-	validationTypeMap
-	validationTypeRepeatedVarint
-	validationTypeRepeatedFixed32
-	validationTypeRepeatedFixed64
-	validationTypeVarint
-	validationTypeFixed32
-	validationTypeFixed64
-	validationTypeBytes
-	validationTypeUTF8String
-	validationTypeMessageSetItem
-)
-
-func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
-	var vi validationInfo
-	switch {
-	case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
-		switch fd.Kind() {
-		case pref.MessageKind:
-			vi.typ = validationTypeMessage
-			if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
-				vi.mi = getMessageInfo(ot.Field(0).Type)
-			}
-		case pref.GroupKind:
-			vi.typ = validationTypeGroup
-			if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
-				vi.mi = getMessageInfo(ot.Field(0).Type)
-			}
-		case pref.StringKind:
-			if strs.EnforceUTF8(fd) {
-				vi.typ = validationTypeUTF8String
-			}
-		}
-	default:
-		vi = newValidationInfo(fd, ft)
-	}
-	if fd.Cardinality() == pref.Required {
-		// Avoid overflow. The required field check is done with a 64-bit mask, with
-		// any message containing more than 64 required fields always reported as
-		// potentially uninitialized, so it is not important to get a precise count
-		// of the required fields past 64.
-		if mi.numRequiredFields < math.MaxUint8 {
-			mi.numRequiredFields++
-			vi.requiredBit = 1 << (mi.numRequiredFields - 1)
-		}
-	}
-	return vi
-}
-
-func newValidationInfo(fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
-	var vi validationInfo
-	switch {
-	case fd.IsList():
-		switch fd.Kind() {
-		case pref.MessageKind:
-			vi.typ = validationTypeMessage
-			if ft.Kind() == reflect.Slice {
-				vi.mi = getMessageInfo(ft.Elem())
-			}
-		case pref.GroupKind:
-			vi.typ = validationTypeGroup
-			if ft.Kind() == reflect.Slice {
-				vi.mi = getMessageInfo(ft.Elem())
-			}
-		case pref.StringKind:
-			vi.typ = validationTypeBytes
-			if strs.EnforceUTF8(fd) {
-				vi.typ = validationTypeUTF8String
-			}
-		default:
-			switch wireTypes[fd.Kind()] {
-			case protowire.VarintType:
-				vi.typ = validationTypeRepeatedVarint
-			case protowire.Fixed32Type:
-				vi.typ = validationTypeRepeatedFixed32
-			case protowire.Fixed64Type:
-				vi.typ = validationTypeRepeatedFixed64
-			}
-		}
-	case fd.IsMap():
-		vi.typ = validationTypeMap
-		switch fd.MapKey().Kind() {
-		case pref.StringKind:
-			if strs.EnforceUTF8(fd) {
-				vi.keyType = validationTypeUTF8String
-			}
-		}
-		switch fd.MapValue().Kind() {
-		case pref.MessageKind:
-			vi.valType = validationTypeMessage
-			if ft.Kind() == reflect.Map {
-				vi.mi = getMessageInfo(ft.Elem())
-			}
-		case pref.StringKind:
-			if strs.EnforceUTF8(fd) {
-				vi.valType = validationTypeUTF8String
-			}
-		}
-	default:
-		switch fd.Kind() {
-		case pref.MessageKind:
-			vi.typ = validationTypeMessage
-			if !fd.IsWeak() {
-				vi.mi = getMessageInfo(ft)
-			}
-		case pref.GroupKind:
-			vi.typ = validationTypeGroup
-			vi.mi = getMessageInfo(ft)
-		case pref.StringKind:
-			vi.typ = validationTypeBytes
-			if strs.EnforceUTF8(fd) {
-				vi.typ = validationTypeUTF8String
-			}
-		default:
-			switch wireTypes[fd.Kind()] {
-			case protowire.VarintType:
-				vi.typ = validationTypeVarint
-			case protowire.Fixed32Type:
-				vi.typ = validationTypeFixed32
-			case protowire.Fixed64Type:
-				vi.typ = validationTypeFixed64
-			case protowire.BytesType:
-				vi.typ = validationTypeBytes
-			}
-		}
-	}
-	return vi
-}
-
-func (mi *MessageInfo) validate(b []byte, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, result ValidationStatus) {
-	mi.init()
-	type validationState struct {
-		typ              validationType
-		keyType, valType validationType
-		endGroup         protowire.Number
-		mi               *MessageInfo
-		tail             []byte
-		requiredMask     uint64
-	}
-
-	// Pre-allocate some slots to avoid repeated slice reallocation.
-	states := make([]validationState, 0, 16)
-	states = append(states, validationState{
-		typ: validationTypeMessage,
-		mi:  mi,
-	})
-	if groupTag > 0 {
-		states[0].typ = validationTypeGroup
-		states[0].endGroup = groupTag
-	}
-	initialized := true
-	start := len(b)
-State:
-	for len(states) > 0 {
-		st := &states[len(states)-1]
-		for len(b) > 0 {
-			// Parse the tag (field number and wire type).
-			var tag uint64
-			if b[0] < 0x80 {
-				tag = uint64(b[0])
-				b = b[1:]
-			} else if len(b) >= 2 && b[1] < 128 {
-				tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
-				b = b[2:]
-			} else {
-				var n int
-				tag, n = protowire.ConsumeVarint(b)
-				if n < 0 {
-					return out, ValidationInvalid
-				}
-				b = b[n:]
-			}
-			var num protowire.Number
-			if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
-				return out, ValidationInvalid
-			} else {
-				num = protowire.Number(n)
-			}
-			wtyp := protowire.Type(tag & 7)
-
-			if wtyp == protowire.EndGroupType {
-				if st.endGroup == num {
-					goto PopState
-				}
-				return out, ValidationInvalid
-			}
-			var vi validationInfo
-			switch {
-			case st.typ == validationTypeMap:
-				switch num {
-				case 1:
-					vi.typ = st.keyType
-				case 2:
-					vi.typ = st.valType
-					vi.mi = st.mi
-					vi.requiredBit = 1
-				}
-			case flags.ProtoLegacy && st.mi.isMessageSet:
-				switch num {
-				case messageset.FieldItem:
-					vi.typ = validationTypeMessageSetItem
-				}
-			default:
-				var f *coderFieldInfo
-				if int(num) < len(st.mi.denseCoderFields) {
-					f = st.mi.denseCoderFields[num]
-				} else {
-					f = st.mi.coderFields[num]
-				}
-				if f != nil {
-					vi = f.validation
-					if vi.typ == validationTypeMessage && vi.mi == nil {
-						// Probable weak field.
-						//
-						// TODO: Consider storing the results of this lookup somewhere
-						// rather than recomputing it on every validation.
-						fd := st.mi.Desc.Fields().ByNumber(num)
-						if fd == nil || !fd.IsWeak() {
-							break
-						}
-						messageName := fd.Message().FullName()
-						messageType, err := preg.GlobalTypes.FindMessageByName(messageName)
-						switch err {
-						case nil:
-							vi.mi, _ = messageType.(*MessageInfo)
-						case preg.NotFound:
-							vi.typ = validationTypeBytes
-						default:
-							return out, ValidationUnknown
-						}
-					}
-					break
-				}
-				// Possible extension field.
-				//
-				// TODO: We should return ValidationUnknown when:
-				//   1. The resolver is not frozen. (More extensions may be added to it.)
-				//   2. The resolver returns preg.NotFound.
-				// In this case, a type added to the resolver in the future could cause
-				// unmarshaling to begin failing. Supporting this requires some way to
-				// determine if the resolver is frozen.
-				xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), num)
-				if err != nil && err != preg.NotFound {
-					return out, ValidationUnknown
-				}
-				if err == nil {
-					vi = getExtensionFieldInfo(xt).validation
-				}
-			}
-			if vi.requiredBit != 0 {
-				// Check that the field has a compatible wire type.
-				// We only need to consider non-repeated field types,
-				// since repeated fields (and maps) can never be required.
-				ok := false
-				switch vi.typ {
-				case validationTypeVarint:
-					ok = wtyp == protowire.VarintType
-				case validationTypeFixed32:
-					ok = wtyp == protowire.Fixed32Type
-				case validationTypeFixed64:
-					ok = wtyp == protowire.Fixed64Type
-				case validationTypeBytes, validationTypeUTF8String, validationTypeMessage:
-					ok = wtyp == protowire.BytesType
-				case validationTypeGroup:
-					ok = wtyp == protowire.StartGroupType
-				}
-				if ok {
-					st.requiredMask |= vi.requiredBit
-				}
-			}
-
-			switch wtyp {
-			case protowire.VarintType:
-				if len(b) >= 10 {
-					switch {
-					case b[0] < 0x80:
-						b = b[1:]
-					case b[1] < 0x80:
-						b = b[2:]
-					case b[2] < 0x80:
-						b = b[3:]
-					case b[3] < 0x80:
-						b = b[4:]
-					case b[4] < 0x80:
-						b = b[5:]
-					case b[5] < 0x80:
-						b = b[6:]
-					case b[6] < 0x80:
-						b = b[7:]
-					case b[7] < 0x80:
-						b = b[8:]
-					case b[8] < 0x80:
-						b = b[9:]
-					case b[9] < 0x80 && b[9] < 2:
-						b = b[10:]
-					default:
-						return out, ValidationInvalid
-					}
-				} else {
-					switch {
-					case len(b) > 0 && b[0] < 0x80:
-						b = b[1:]
-					case len(b) > 1 && b[1] < 0x80:
-						b = b[2:]
-					case len(b) > 2 && b[2] < 0x80:
-						b = b[3:]
-					case len(b) > 3 && b[3] < 0x80:
-						b = b[4:]
-					case len(b) > 4 && b[4] < 0x80:
-						b = b[5:]
-					case len(b) > 5 && b[5] < 0x80:
-						b = b[6:]
-					case len(b) > 6 && b[6] < 0x80:
-						b = b[7:]
-					case len(b) > 7 && b[7] < 0x80:
-						b = b[8:]
-					case len(b) > 8 && b[8] < 0x80:
-						b = b[9:]
-					case len(b) > 9 && b[9] < 2:
-						b = b[10:]
-					default:
-						return out, ValidationInvalid
-					}
-				}
-				continue State
-			case protowire.BytesType:
-				var size uint64
-				if len(b) >= 1 && b[0] < 0x80 {
-					size = uint64(b[0])
-					b = b[1:]
-				} else if len(b) >= 2 && b[1] < 128 {
-					size = uint64(b[0]&0x7f) + uint64(b[1])<<7
-					b = b[2:]
-				} else {
-					var n int
-					size, n = protowire.ConsumeVarint(b)
-					if n < 0 {
-						return out, ValidationInvalid
-					}
-					b = b[n:]
-				}
-				if size > uint64(len(b)) {
-					return out, ValidationInvalid
-				}
-				v := b[:size]
-				b = b[size:]
-				switch vi.typ {
-				case validationTypeMessage:
-					if vi.mi == nil {
-						return out, ValidationUnknown
-					}
-					vi.mi.init()
-					fallthrough
-				case validationTypeMap:
-					if vi.mi != nil {
-						vi.mi.init()
-					}
-					states = append(states, validationState{
-						typ:     vi.typ,
-						keyType: vi.keyType,
-						valType: vi.valType,
-						mi:      vi.mi,
-						tail:    b,
-					})
-					b = v
-					continue State
-				case validationTypeRepeatedVarint:
-					// Packed field.
-					for len(v) > 0 {
-						_, n := protowire.ConsumeVarint(v)
-						if n < 0 {
-							return out, ValidationInvalid
-						}
-						v = v[n:]
-					}
-				case validationTypeRepeatedFixed32:
-					// Packed field.
-					if len(v)%4 != 0 {
-						return out, ValidationInvalid
-					}
-				case validationTypeRepeatedFixed64:
-					// Packed field.
-					if len(v)%8 != 0 {
-						return out, ValidationInvalid
-					}
-				case validationTypeUTF8String:
-					if !utf8.Valid(v) {
-						return out, ValidationInvalid
-					}
-				}
-			case protowire.Fixed32Type:
-				if len(b) < 4 {
-					return out, ValidationInvalid
-				}
-				b = b[4:]
-			case protowire.Fixed64Type:
-				if len(b) < 8 {
-					return out, ValidationInvalid
-				}
-				b = b[8:]
-			case protowire.StartGroupType:
-				switch {
-				case vi.typ == validationTypeGroup:
-					if vi.mi == nil {
-						return out, ValidationUnknown
-					}
-					vi.mi.init()
-					states = append(states, validationState{
-						typ:      validationTypeGroup,
-						mi:       vi.mi,
-						endGroup: num,
-					})
-					continue State
-				case flags.ProtoLegacy && vi.typ == validationTypeMessageSetItem:
-					typeid, v, n, err := messageset.ConsumeFieldValue(b, false)
-					if err != nil {
-						return out, ValidationInvalid
-					}
-					xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), typeid)
-					switch {
-					case err == preg.NotFound:
-						b = b[n:]
-					case err != nil:
-						return out, ValidationUnknown
-					default:
-						xvi := getExtensionFieldInfo(xt).validation
-						if xvi.mi != nil {
-							xvi.mi.init()
-						}
-						states = append(states, validationState{
-							typ:  xvi.typ,
-							mi:   xvi.mi,
-							tail: b[n:],
-						})
-						b = v
-						continue State
-					}
-				default:
-					n := protowire.ConsumeFieldValue(num, wtyp, b)
-					if n < 0 {
-						return out, ValidationInvalid
-					}
-					b = b[n:]
-				}
-			default:
-				return out, ValidationInvalid
-			}
-		}
-		if st.endGroup != 0 {
-			return out, ValidationInvalid
-		}
-		if len(b) != 0 {
-			return out, ValidationInvalid
-		}
-		b = st.tail
-	PopState:
-		numRequiredFields := 0
-		switch st.typ {
-		case validationTypeMessage, validationTypeGroup:
-			numRequiredFields = int(st.mi.numRequiredFields)
-		case validationTypeMap:
-			// If this is a map field with a message value that contains
-			// required fields, require that the value be present.
-			if st.mi != nil && st.mi.numRequiredFields > 0 {
-				numRequiredFields = 1
-			}
-		}
-		// If there are more than 64 required fields, this check will
-		// always fail and we will report that the message is potentially
-		// uninitialized.
-		if numRequiredFields > 0 && bits.OnesCount64(st.requiredMask) != numRequiredFields {
-			initialized = false
-		}
-		states = states[:len(states)-1]
-	}
-	out.n = start - len(b)
-	if initialized {
-		out.initialized = true
-	}
-	return out, ValidationValid
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/weak.go b/vendor/google.golang.org/protobuf/internal/impl/weak.go
deleted file mode 100644
index 009cbef..0000000
--- a/vendor/google.golang.org/protobuf/internal/impl/weak.go
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package impl
-
-import (
-	"fmt"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-// weakFields adds methods to the exported WeakFields type for internal use.
-//
-// The exported type is an alias to an unnamed type, so methods can't be
-// defined directly on it.
-type weakFields WeakFields
-
-func (w weakFields) get(num pref.FieldNumber) (pref.ProtoMessage, bool) {
-	m, ok := w[int32(num)]
-	return m, ok
-}
-
-func (w *weakFields) set(num pref.FieldNumber, m pref.ProtoMessage) {
-	if *w == nil {
-		*w = make(weakFields)
-	}
-	(*w)[int32(num)] = m
-}
-
-func (w *weakFields) clear(num pref.FieldNumber) {
-	delete(*w, int32(num))
-}
-
-func (Export) HasWeak(w WeakFields, num pref.FieldNumber) bool {
-	_, ok := w[int32(num)]
-	return ok
-}
-
-func (Export) ClearWeak(w *WeakFields, num pref.FieldNumber) {
-	delete(*w, int32(num))
-}
-
-func (Export) GetWeak(w WeakFields, num pref.FieldNumber, name pref.FullName) pref.ProtoMessage {
-	if m, ok := w[int32(num)]; ok {
-		return m
-	}
-	mt, _ := protoregistry.GlobalTypes.FindMessageByName(name)
-	if mt == nil {
-		panic(fmt.Sprintf("message %v for weak field is not linked in", name))
-	}
-	return mt.Zero().Interface()
-}
-
-func (Export) SetWeak(w *WeakFields, num pref.FieldNumber, name pref.FullName, m pref.ProtoMessage) {
-	if m != nil {
-		mt, _ := protoregistry.GlobalTypes.FindMessageByName(name)
-		if mt == nil {
-			panic(fmt.Sprintf("message %v for weak field is not linked in", name))
-		}
-		if mt != m.ProtoReflect().Type() {
-			panic(fmt.Sprintf("invalid message type for weak field: got %T, want %T", m, mt.Zero().Interface()))
-		}
-	}
-	if m == nil || !m.ProtoReflect().IsValid() {
-		delete(*w, int32(num))
-		return
-	}
-	if *w == nil {
-		*w = make(weakFields)
-	}
-	(*w)[int32(num)] = m
-}
diff --git a/vendor/google.golang.org/protobuf/internal/mapsort/mapsort.go b/vendor/google.golang.org/protobuf/internal/mapsort/mapsort.go
deleted file mode 100644
index a3de1cf..0000000
--- a/vendor/google.golang.org/protobuf/internal/mapsort/mapsort.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package mapsort provides sorted access to maps.
-package mapsort
-
-import (
-	"sort"
-
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Range iterates over every map entry in sorted key order,
-// calling f for each key and value encountered.
-func Range(mapv protoreflect.Map, keyKind protoreflect.Kind, f func(protoreflect.MapKey, protoreflect.Value) bool) {
-	var keys []protoreflect.MapKey
-	mapv.Range(func(key protoreflect.MapKey, _ protoreflect.Value) bool {
-		keys = append(keys, key)
-		return true
-	})
-	sort.Slice(keys, func(i, j int) bool {
-		switch keyKind {
-		case protoreflect.BoolKind:
-			return !keys[i].Bool() && keys[j].Bool()
-		case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind,
-			protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
-			return keys[i].Int() < keys[j].Int()
-		case protoreflect.Uint32Kind, protoreflect.Fixed32Kind,
-			protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
-			return keys[i].Uint() < keys[j].Uint()
-		case protoreflect.StringKind:
-			return keys[i].String() < keys[j].String()
-		default:
-			panic("invalid kind: " + keyKind.String())
-		}
-	})
-	for _, key := range keys {
-		if !f(key, mapv.Get(key)) {
-			break
-		}
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/internal/pragma/pragma.go b/vendor/google.golang.org/protobuf/internal/pragma/pragma.go
deleted file mode 100644
index 49dc4fc..0000000
--- a/vendor/google.golang.org/protobuf/internal/pragma/pragma.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package pragma provides types that can be embedded into a struct to
-// statically enforce or prevent certain language properties.
-package pragma
-
-import "sync"
-
-// NoUnkeyedLiterals can be embedded in a struct to prevent unkeyed literals.
-type NoUnkeyedLiterals struct{}
-
-// DoNotImplement can be embedded in an interface to prevent trivial
-// implementations of the interface.
-//
-// This is useful to prevent unauthorized implementations of an interface
-// so that it can be extended in the future for any protobuf language changes.
-type DoNotImplement interface{ ProtoInternal(DoNotImplement) }
-
-// DoNotCompare can be embedded in a struct to prevent comparability.
-type DoNotCompare [0]func()
-
-// DoNotCopy can be embedded in a struct to help prevent shallow copies.
-// This does not rely on a Go language feature, but rather a special case
-// within the vet checker.
-//
-// See https://golang.org/issues/8005.
-type DoNotCopy [0]sync.Mutex
diff --git a/vendor/google.golang.org/protobuf/internal/set/ints.go b/vendor/google.golang.org/protobuf/internal/set/ints.go
deleted file mode 100644
index d3d7f89..0000000
--- a/vendor/google.golang.org/protobuf/internal/set/ints.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package set provides simple set data structures for uint64s.
-package set
-
-import "math/bits"
-
-// int64s represents a set of integers within the range of 0..63.
-type int64s uint64
-
-func (bs *int64s) Len() int {
-	return bits.OnesCount64(uint64(*bs))
-}
-func (bs *int64s) Has(n uint64) bool {
-	return uint64(*bs)&(uint64(1)<<n) > 0
-}
-func (bs *int64s) Set(n uint64) {
-	*(*uint64)(bs) |= uint64(1) << n
-}
-func (bs *int64s) Clear(n uint64) {
-	*(*uint64)(bs) &^= uint64(1) << n
-}
-
-// Ints represents a set of integers within the range of 0..math.MaxUint64.
-type Ints struct {
-	lo int64s
-	hi map[uint64]struct{}
-}
-
-func (bs *Ints) Len() int {
-	return bs.lo.Len() + len(bs.hi)
-}
-func (bs *Ints) Has(n uint64) bool {
-	if n < 64 {
-		return bs.lo.Has(n)
-	}
-	_, ok := bs.hi[n]
-	return ok
-}
-func (bs *Ints) Set(n uint64) {
-	if n < 64 {
-		bs.lo.Set(n)
-		return
-	}
-	if bs.hi == nil {
-		bs.hi = make(map[uint64]struct{})
-	}
-	bs.hi[n] = struct{}{}
-}
-func (bs *Ints) Clear(n uint64) {
-	if n < 64 {
-		bs.lo.Clear(n)
-		return
-	}
-	delete(bs.hi, n)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings.go b/vendor/google.golang.org/protobuf/internal/strs/strings.go
deleted file mode 100644
index 0b74e76..0000000
--- a/vendor/google.golang.org/protobuf/internal/strs/strings.go
+++ /dev/null
@@ -1,196 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package strs provides string manipulation functionality specific to protobuf.
-package strs
-
-import (
-	"go/token"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/internal/flags"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// EnforceUTF8 reports whether to enforce strict UTF-8 validation.
-func EnforceUTF8(fd protoreflect.FieldDescriptor) bool {
-	if flags.ProtoLegacy {
-		if fd, ok := fd.(interface{ EnforceUTF8() bool }); ok {
-			return fd.EnforceUTF8()
-		}
-	}
-	return fd.Syntax() == protoreflect.Proto3
-}
-
-// GoCamelCase camel-cases a protobuf name for use as a Go identifier.
-//
-// If there is an interior underscore followed by a lower case letter,
-// drop the underscore and convert the letter to upper case.
-func GoCamelCase(s string) string {
-	// Invariant: if the next letter is lower case, it must be converted
-	// to upper case.
-	// That is, we process a word at a time, where words are marked by _ or
-	// upper case letter. Digits are treated as words.
-	var b []byte
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		switch {
-		case c == '.' && i+1 < len(s) && isASCIILower(s[i+1]):
-			// Skip over '.' in ".{{lowercase}}".
-		case c == '.':
-			b = append(b, '_') // convert '.' to '_'
-		case c == '_' && (i == 0 || s[i-1] == '.'):
-			// Convert initial '_' to ensure we start with a capital letter.
-			// Do the same for '_' after '.' to match historic behavior.
-			b = append(b, 'X') // convert '_' to 'X'
-		case c == '_' && i+1 < len(s) && isASCIILower(s[i+1]):
-			// Skip over '_' in "_{{lowercase}}".
-		case isASCIIDigit(c):
-			b = append(b, c)
-		default:
-			// Assume we have a letter now - if not, it's a bogus identifier.
-			// The next word is a sequence of characters that must start upper case.
-			if isASCIILower(c) {
-				c -= 'a' - 'A' // convert lowercase to uppercase
-			}
-			b = append(b, c)
-
-			// Accept lower case sequence that follows.
-			for ; i+1 < len(s) && isASCIILower(s[i+1]); i++ {
-				b = append(b, s[i+1])
-			}
-		}
-	}
-	return string(b)
-}
-
-// GoSanitized converts a string to a valid Go identifier.
-func GoSanitized(s string) string {
-	// Sanitize the input to the set of valid characters,
-	// which must be '_' or be in the Unicode L or N categories.
-	s = strings.Map(func(r rune) rune {
-		if unicode.IsLetter(r) || unicode.IsDigit(r) {
-			return r
-		}
-		return '_'
-	}, s)
-
-	// Prepend '_' in the event of a Go keyword conflict or if
-	// the identifier is invalid (does not start in the Unicode L category).
-	r, _ := utf8.DecodeRuneInString(s)
-	if token.Lookup(s).IsKeyword() || !unicode.IsLetter(r) {
-		return "_" + s
-	}
-	return s
-}
-
-// JSONCamelCase converts a snake_case identifier to a camelCase identifier,
-// according to the protobuf JSON specification.
-func JSONCamelCase(s string) string {
-	var b []byte
-	var wasUnderscore bool
-	for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
-		c := s[i]
-		if c != '_' {
-			if wasUnderscore && isASCIILower(c) {
-				c -= 'a' - 'A' // convert to uppercase
-			}
-			b = append(b, c)
-		}
-		wasUnderscore = c == '_'
-	}
-	return string(b)
-}
-
-// JSONSnakeCase converts a camelCase identifier to a snake_case identifier,
-// according to the protobuf JSON specification.
-func JSONSnakeCase(s string) string {
-	var b []byte
-	for i := 0; i < len(s); i++ { // proto identifiers are always ASCII
-		c := s[i]
-		if isASCIIUpper(c) {
-			b = append(b, '_')
-			c += 'a' - 'A' // convert to lowercase
-		}
-		b = append(b, c)
-	}
-	return string(b)
-}
-
-// MapEntryName derives the name of the map entry message given the field name.
-// See protoc v3.8.0: src/google/protobuf/descriptor.cc:254-276,6057
-func MapEntryName(s string) string {
-	var b []byte
-	upperNext := true
-	for _, c := range s {
-		switch {
-		case c == '_':
-			upperNext = true
-		case upperNext:
-			b = append(b, byte(unicode.ToUpper(c)))
-			upperNext = false
-		default:
-			b = append(b, byte(c))
-		}
-	}
-	b = append(b, "Entry"...)
-	return string(b)
-}
-
-// EnumValueName derives the camel-cased enum value name.
-// See protoc v3.8.0: src/google/protobuf/descriptor.cc:297-313
-func EnumValueName(s string) string {
-	var b []byte
-	upperNext := true
-	for _, c := range s {
-		switch {
-		case c == '_':
-			upperNext = true
-		case upperNext:
-			b = append(b, byte(unicode.ToUpper(c)))
-			upperNext = false
-		default:
-			b = append(b, byte(unicode.ToLower(c)))
-			upperNext = false
-		}
-	}
-	return string(b)
-}
-
-// TrimEnumPrefix trims the enum name prefix from an enum value name,
-// where the prefix is all lowercase without underscores.
-// See protoc v3.8.0: src/google/protobuf/descriptor.cc:330-375
-func TrimEnumPrefix(s, prefix string) string {
-	s0 := s // original input
-	for len(s) > 0 && len(prefix) > 0 {
-		if s[0] == '_' {
-			s = s[1:]
-			continue
-		}
-		if unicode.ToLower(rune(s[0])) != rune(prefix[0]) {
-			return s0 // no prefix match
-		}
-		s, prefix = s[1:], prefix[1:]
-	}
-	if len(prefix) > 0 {
-		return s0 // no prefix match
-	}
-	s = strings.TrimLeft(s, "_")
-	if len(s) == 0 {
-		return s0 // avoid returning empty string
-	}
-	return s
-}
-
-func isASCIILower(c byte) bool {
-	return 'a' <= c && c <= 'z'
-}
-func isASCIIUpper(c byte) bool {
-	return 'A' <= c && c <= 'Z'
-}
-func isASCIIDigit(c byte) bool {
-	return '0' <= c && c <= '9'
-}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go b/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go
deleted file mode 100644
index 85e074c..0000000
--- a/vendor/google.golang.org/protobuf/internal/strs/strings_pure.go
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build purego appengine
-
-package strs
-
-import pref "google.golang.org/protobuf/reflect/protoreflect"
-
-func UnsafeString(b []byte) string {
-	return string(b)
-}
-
-func UnsafeBytes(s string) []byte {
-	return []byte(s)
-}
-
-type Builder struct{}
-
-func (*Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName {
-	return prefix.Append(name)
-}
-
-func (*Builder) MakeString(b []byte) string {
-	return string(b)
-}
diff --git a/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe.go b/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe.go
deleted file mode 100644
index 2160c70..0000000
--- a/vendor/google.golang.org/protobuf/internal/strs/strings_unsafe.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !purego,!appengine
-
-package strs
-
-import (
-	"unsafe"
-
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-type (
-	stringHeader struct {
-		Data unsafe.Pointer
-		Len  int
-	}
-	sliceHeader struct {
-		Data unsafe.Pointer
-		Len  int
-		Cap  int
-	}
-)
-
-// UnsafeString returns an unsafe string reference of b.
-// The caller must treat the input slice as immutable.
-//
-// WARNING: Use carefully. The returned result must not leak to the end user
-// unless the input slice is provably immutable.
-func UnsafeString(b []byte) (s string) {
-	src := (*sliceHeader)(unsafe.Pointer(&b))
-	dst := (*stringHeader)(unsafe.Pointer(&s))
-	dst.Data = src.Data
-	dst.Len = src.Len
-	return s
-}
-
-// UnsafeBytes returns an unsafe bytes slice reference of s.
-// The caller must treat returned slice as immutable.
-//
-// WARNING: Use carefully. The returned result must not leak to the end user.
-func UnsafeBytes(s string) (b []byte) {
-	src := (*stringHeader)(unsafe.Pointer(&s))
-	dst := (*sliceHeader)(unsafe.Pointer(&b))
-	dst.Data = src.Data
-	dst.Len = src.Len
-	dst.Cap = src.Len
-	return b
-}
-
-// Builder builds a set of strings with shared lifetime.
-// This differs from strings.Builder, which is for building a single string.
-type Builder struct {
-	buf []byte
-}
-
-// AppendFullName is equivalent to protoreflect.FullName.Append,
-// but optimized for large batches where each name has a shared lifetime.
-func (sb *Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName {
-	n := len(prefix) + len(".") + len(name)
-	if len(prefix) == 0 {
-		n -= len(".")
-	}
-	sb.grow(n)
-	sb.buf = append(sb.buf, prefix...)
-	sb.buf = append(sb.buf, '.')
-	sb.buf = append(sb.buf, name...)
-	return pref.FullName(sb.last(n))
-}
-
-// MakeString is equivalent to string(b), but optimized for large batches
-// with a shared lifetime.
-func (sb *Builder) MakeString(b []byte) string {
-	sb.grow(len(b))
-	sb.buf = append(sb.buf, b...)
-	return sb.last(len(b))
-}
-
-func (sb *Builder) grow(n int) {
-	if cap(sb.buf)-len(sb.buf) >= n {
-		return
-	}
-
-	// Unlike strings.Builder, we do not need to copy over the contents
-	// of the old buffer since our builder provides no API for
-	// retrieving previously created strings.
-	sb.buf = make([]byte, 2*(cap(sb.buf)+n))
-}
-
-func (sb *Builder) last(n int) string {
-	return UnsafeString(sb.buf[len(sb.buf)-n:])
-}
diff --git a/vendor/google.golang.org/protobuf/internal/version/version.go b/vendor/google.golang.org/protobuf/internal/version/version.go
deleted file mode 100644
index 4088e59..0000000
--- a/vendor/google.golang.org/protobuf/internal/version/version.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package version records versioning information about this module.
-package version
-
-import (
-	"fmt"
-	"strings"
-)
-
-// These constants determine the current version of this module.
-//
-//
-// For our release process, we enforce the following rules:
-//	* Tagged releases use a tag that is identical to String.
-//	* Tagged releases never reference a commit where the String
-//	contains "devel".
-//	* The set of all commits in this repository where String
-//	does not contain "devel" must have a unique String.
-//
-//
-// Steps for tagging a new release:
-//	1. Create a new CL.
-//
-//	2. Update Minor, Patch, and/or PreRelease as necessary.
-//	PreRelease must not contain the string "devel".
-//
-//	3. Since the last released minor version, have there been any changes to
-//	generator that relies on new functionality in the runtime?
-//	If yes, then increment RequiredGenerated.
-//
-//	4. Since the last released minor version, have there been any changes to
-//	the runtime that removes support for old .pb.go source code?
-//	If yes, then increment SupportMinimum.
-//
-//	5. Send out the CL for review and submit it.
-//	Note that the next CL in step 8 must be submitted after this CL
-//	without any other CLs in-between.
-//
-//	6. Tag a new version, where the tag is is the current String.
-//
-//	7. Write release notes for all notable changes
-//	between this release and the last release.
-//
-//	8. Create a new CL.
-//
-//	9. Update PreRelease to include the string "devel".
-//	For example: "" -> "devel" or "rc.1" -> "rc.1.devel"
-//
-//	10. Send out the CL for review and submit it.
-const (
-	Major      = 1
-	Minor      = 23
-	Patch      = 0
-	PreRelease = ""
-)
-
-// String formats the version string for this module in semver format.
-//
-// Examples:
-//	v1.20.1
-//	v1.21.0-rc.1
-func String() string {
-	v := fmt.Sprintf("v%d.%d.%d", Major, Minor, Patch)
-	if PreRelease != "" {
-		v += "-" + PreRelease
-
-		// TODO: Add metadata about the commit or build hash.
-		// See https://golang.org/issue/29814
-		// See https://golang.org/issue/33533
-		var metadata string
-		if strings.Contains(PreRelease, "devel") && metadata != "" {
-			v += "+" + metadata
-		}
-	}
-	return v
-}
diff --git a/vendor/google.golang.org/protobuf/proto/checkinit.go b/vendor/google.golang.org/protobuf/proto/checkinit.go
deleted file mode 100644
index 3e9a6a2..0000000
--- a/vendor/google.golang.org/protobuf/proto/checkinit.go
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoiface"
-)
-
-// CheckInitialized returns an error if any required fields in m are not set.
-func CheckInitialized(m Message) error {
-	// Treat a nil message interface as an "untyped" empty message,
-	// which we assume to have no required fields.
-	if m == nil {
-		return nil
-	}
-
-	return checkInitialized(m.ProtoReflect())
-}
-
-// CheckInitialized returns an error if any required fields in m are not set.
-func checkInitialized(m protoreflect.Message) error {
-	if methods := protoMethods(m); methods != nil && methods.CheckInitialized != nil {
-		_, err := methods.CheckInitialized(protoiface.CheckInitializedInput{
-			Message: m,
-		})
-		return err
-	}
-	return checkInitializedSlow(m)
-}
-
-func checkInitializedSlow(m protoreflect.Message) error {
-	md := m.Descriptor()
-	fds := md.Fields()
-	for i, nums := 0, md.RequiredNumbers(); i < nums.Len(); i++ {
-		fd := fds.ByNumber(nums.Get(i))
-		if !m.Has(fd) {
-			return errors.RequiredNotSet(string(fd.FullName()))
-		}
-	}
-	var err error
-	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		switch {
-		case fd.IsList():
-			if fd.Message() == nil {
-				return true
-			}
-			for i, list := 0, v.List(); i < list.Len() && err == nil; i++ {
-				err = checkInitialized(list.Get(i).Message())
-			}
-		case fd.IsMap():
-			if fd.MapValue().Message() == nil {
-				return true
-			}
-			v.Map().Range(func(key protoreflect.MapKey, v protoreflect.Value) bool {
-				err = checkInitialized(v.Message())
-				return err == nil
-			})
-		default:
-			if fd.Message() == nil {
-				return true
-			}
-			err = checkInitialized(v.Message())
-		}
-		return err == nil
-	})
-	return err
-}
diff --git a/vendor/google.golang.org/protobuf/proto/decode.go b/vendor/google.golang.org/protobuf/proto/decode.go
deleted file mode 100644
index 1282147..0000000
--- a/vendor/google.golang.org/protobuf/proto/decode.go
+++ /dev/null
@@ -1,270 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/flags"
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-	"google.golang.org/protobuf/runtime/protoiface"
-)
-
-// UnmarshalOptions configures the unmarshaler.
-//
-// Example usage:
-//   err := UnmarshalOptions{DiscardUnknown: true}.Unmarshal(b, m)
-type UnmarshalOptions struct {
-	pragma.NoUnkeyedLiterals
-
-	// Merge merges the input into the destination message.
-	// The default behavior is to always reset the message before unmarshaling,
-	// unless Merge is specified.
-	Merge bool
-
-	// AllowPartial accepts input for messages that will result in missing
-	// required fields. If AllowPartial is false (the default), Unmarshal will
-	// return an error if there are any missing required fields.
-	AllowPartial bool
-
-	// If DiscardUnknown is set, unknown fields are ignored.
-	DiscardUnknown bool
-
-	// Resolver is used for looking up types when unmarshaling extension fields.
-	// If nil, this defaults to using protoregistry.GlobalTypes.
-	Resolver interface {
-		FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
-		FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
-	}
-}
-
-// Unmarshal parses the wire-format message in b and places the result in m.
-func Unmarshal(b []byte, m Message) error {
-	_, err := UnmarshalOptions{}.unmarshal(b, m.ProtoReflect())
-	return err
-}
-
-// Unmarshal parses the wire-format message in b and places the result in m.
-func (o UnmarshalOptions) Unmarshal(b []byte, m Message) error {
-	_, err := o.unmarshal(b, m.ProtoReflect())
-	return err
-}
-
-// UnmarshalState parses a wire-format message and places the result in m.
-//
-// This method permits fine-grained control over the unmarshaler.
-// Most users should use Unmarshal instead.
-func (o UnmarshalOptions) UnmarshalState(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-	return o.unmarshal(in.Buf, in.Message)
-}
-
-func (o UnmarshalOptions) unmarshal(b []byte, m protoreflect.Message) (out protoiface.UnmarshalOutput, err error) {
-	if o.Resolver == nil {
-		o.Resolver = protoregistry.GlobalTypes
-	}
-	if !o.Merge {
-		Reset(m.Interface()) // TODO
-	}
-	allowPartial := o.AllowPartial
-	o.Merge = true
-	o.AllowPartial = true
-	methods := protoMethods(m)
-	if methods != nil && methods.Unmarshal != nil &&
-		!(o.DiscardUnknown && methods.Flags&protoiface.SupportUnmarshalDiscardUnknown == 0) {
-		in := protoiface.UnmarshalInput{
-			Message:  m,
-			Buf:      b,
-			Resolver: o.Resolver,
-		}
-		if o.DiscardUnknown {
-			in.Flags |= protoiface.UnmarshalDiscardUnknown
-		}
-		out, err = methods.Unmarshal(in)
-	} else {
-		err = o.unmarshalMessageSlow(b, m)
-	}
-	if err != nil {
-		return out, err
-	}
-	if allowPartial || (out.Flags&protoiface.UnmarshalInitialized != 0) {
-		return out, nil
-	}
-	return out, checkInitialized(m)
-}
-
-func (o UnmarshalOptions) unmarshalMessage(b []byte, m protoreflect.Message) error {
-	_, err := o.unmarshal(b, m)
-	return err
-}
-
-func (o UnmarshalOptions) unmarshalMessageSlow(b []byte, m protoreflect.Message) error {
-	md := m.Descriptor()
-	if messageset.IsMessageSet(md) {
-		return unmarshalMessageSet(b, m, o)
-	}
-	fields := md.Fields()
-	for len(b) > 0 {
-		// Parse the tag (field number and wire type).
-		num, wtyp, tagLen := protowire.ConsumeTag(b)
-		if tagLen < 0 {
-			return protowire.ParseError(tagLen)
-		}
-		if num > protowire.MaxValidNumber {
-			return errors.New("invalid field number")
-		}
-
-		// Find the field descriptor for this field number.
-		fd := fields.ByNumber(num)
-		if fd == nil && md.ExtensionRanges().Has(num) {
-			extType, err := o.Resolver.FindExtensionByNumber(md.FullName(), num)
-			if err != nil && err != protoregistry.NotFound {
-				return errors.New("%v: unable to resolve extension %v: %v", md.FullName(), num, err)
-			}
-			if extType != nil {
-				fd = extType.TypeDescriptor()
-			}
-		}
-		var err error
-		if fd == nil {
-			err = errUnknown
-		} else if flags.ProtoLegacy {
-			if fd.IsWeak() && fd.Message().IsPlaceholder() {
-				err = errUnknown // weak referent is not linked in
-			}
-		}
-
-		// Parse the field value.
-		var valLen int
-		switch {
-		case err != nil:
-		case fd.IsList():
-			valLen, err = o.unmarshalList(b[tagLen:], wtyp, m.Mutable(fd).List(), fd)
-		case fd.IsMap():
-			valLen, err = o.unmarshalMap(b[tagLen:], wtyp, m.Mutable(fd).Map(), fd)
-		default:
-			valLen, err = o.unmarshalSingular(b[tagLen:], wtyp, m, fd)
-		}
-		if err != nil {
-			if err != errUnknown {
-				return err
-			}
-			valLen = protowire.ConsumeFieldValue(num, wtyp, b[tagLen:])
-			if valLen < 0 {
-				return protowire.ParseError(valLen)
-			}
-			if !o.DiscardUnknown {
-				m.SetUnknown(append(m.GetUnknown(), b[:tagLen+valLen]...))
-			}
-		}
-		b = b[tagLen+valLen:]
-	}
-	return nil
-}
-
-func (o UnmarshalOptions) unmarshalSingular(b []byte, wtyp protowire.Type, m protoreflect.Message, fd protoreflect.FieldDescriptor) (n int, err error) {
-	v, n, err := o.unmarshalScalar(b, wtyp, fd)
-	if err != nil {
-		return 0, err
-	}
-	switch fd.Kind() {
-	case protoreflect.GroupKind, protoreflect.MessageKind:
-		m2 := m.Mutable(fd).Message()
-		if err := o.unmarshalMessage(v.Bytes(), m2); err != nil {
-			return n, err
-		}
-	default:
-		// Non-message scalars replace the previous value.
-		m.Set(fd, v)
-	}
-	return n, nil
-}
-
-func (o UnmarshalOptions) unmarshalMap(b []byte, wtyp protowire.Type, mapv protoreflect.Map, fd protoreflect.FieldDescriptor) (n int, err error) {
-	if wtyp != protowire.BytesType {
-		return 0, errUnknown
-	}
-	b, n = protowire.ConsumeBytes(b)
-	if n < 0 {
-		return 0, protowire.ParseError(n)
-	}
-	var (
-		keyField = fd.MapKey()
-		valField = fd.MapValue()
-		key      protoreflect.Value
-		val      protoreflect.Value
-		haveKey  bool
-		haveVal  bool
-	)
-	switch valField.Kind() {
-	case protoreflect.GroupKind, protoreflect.MessageKind:
-		val = mapv.NewValue()
-	}
-	// Map entries are represented as a two-element message with fields
-	// containing the key and value.
-	for len(b) > 0 {
-		num, wtyp, n := protowire.ConsumeTag(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		if num > protowire.MaxValidNumber {
-			return 0, errors.New("invalid field number")
-		}
-		b = b[n:]
-		err = errUnknown
-		switch num {
-		case 1:
-			key, n, err = o.unmarshalScalar(b, wtyp, keyField)
-			if err != nil {
-				break
-			}
-			haveKey = true
-		case 2:
-			var v protoreflect.Value
-			v, n, err = o.unmarshalScalar(b, wtyp, valField)
-			if err != nil {
-				break
-			}
-			switch valField.Kind() {
-			case protoreflect.GroupKind, protoreflect.MessageKind:
-				if err := o.unmarshalMessage(v.Bytes(), val.Message()); err != nil {
-					return 0, err
-				}
-			default:
-				val = v
-			}
-			haveVal = true
-		}
-		if err == errUnknown {
-			n = protowire.ConsumeFieldValue(num, wtyp, b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-		} else if err != nil {
-			return 0, err
-		}
-		b = b[n:]
-	}
-	// Every map entry should have entries for key and value, but this is not strictly required.
-	if !haveKey {
-		key = keyField.Default()
-	}
-	if !haveVal {
-		switch valField.Kind() {
-		case protoreflect.GroupKind, protoreflect.MessageKind:
-		default:
-			val = valField.Default()
-		}
-	}
-	mapv.Set(key.MapKey(), val)
-	return n, nil
-}
-
-// errUnknown is used internally to indicate fields which should be added
-// to the unknown field set of a message. It is never returned from an exported
-// function.
-var errUnknown = errors.New("BUG: internal error (unknown)")
diff --git a/vendor/google.golang.org/protobuf/proto/decode_gen.go b/vendor/google.golang.org/protobuf/proto/decode_gen.go
deleted file mode 100644
index d6dc904..0000000
--- a/vendor/google.golang.org/protobuf/proto/decode_gen.go
+++ /dev/null
@@ -1,603 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package proto
-
-import (
-	"math"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/strs"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// unmarshalScalar decodes a value of the given kind.
-//
-// Message values are decoded into a []byte which aliases the input data.
-func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp protowire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
-	switch fd.Kind() {
-	case protoreflect.BoolKind:
-		if wtyp != protowire.VarintType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfBool(protowire.DecodeBool(v)), n, nil
-	case protoreflect.EnumKind:
-		if wtyp != protowire.VarintType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), n, nil
-	case protoreflect.Int32Kind:
-		if wtyp != protowire.VarintType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfInt32(int32(v)), n, nil
-	case protoreflect.Sint32Kind:
-		if wtyp != protowire.VarintType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), n, nil
-	case protoreflect.Uint32Kind:
-		if wtyp != protowire.VarintType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfUint32(uint32(v)), n, nil
-	case protoreflect.Int64Kind:
-		if wtyp != protowire.VarintType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfInt64(int64(v)), n, nil
-	case protoreflect.Sint64Kind:
-		if wtyp != protowire.VarintType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), n, nil
-	case protoreflect.Uint64Kind:
-		if wtyp != protowire.VarintType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfUint64(v), n, nil
-	case protoreflect.Sfixed32Kind:
-		if wtyp != protowire.Fixed32Type {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed32(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfInt32(int32(v)), n, nil
-	case protoreflect.Fixed32Kind:
-		if wtyp != protowire.Fixed32Type {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed32(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfUint32(uint32(v)), n, nil
-	case protoreflect.FloatKind:
-		if wtyp != protowire.Fixed32Type {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed32(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), n, nil
-	case protoreflect.Sfixed64Kind:
-		if wtyp != protowire.Fixed64Type {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed64(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfInt64(int64(v)), n, nil
-	case protoreflect.Fixed64Kind:
-		if wtyp != protowire.Fixed64Type {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed64(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfUint64(v), n, nil
-	case protoreflect.DoubleKind:
-		if wtyp != protowire.Fixed64Type {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed64(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfFloat64(math.Float64frombits(v)), n, nil
-	case protoreflect.StringKind:
-		if wtyp != protowire.BytesType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
-			return protoreflect.Value{}, 0, errors.InvalidUTF8(string(fd.FullName()))
-		}
-		return protoreflect.ValueOfString(string(v)), n, nil
-	case protoreflect.BytesKind:
-		if wtyp != protowire.BytesType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), n, nil
-	case protoreflect.MessageKind:
-		if wtyp != protowire.BytesType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfBytes(v), n, nil
-	case protoreflect.GroupKind:
-		if wtyp != protowire.StartGroupType {
-			return val, 0, errUnknown
-		}
-		v, n := protowire.ConsumeGroup(fd.Number(), b)
-		if n < 0 {
-			return val, 0, protowire.ParseError(n)
-		}
-		return protoreflect.ValueOfBytes(v), n, nil
-	default:
-		return val, 0, errUnknown
-	}
-}
-
-func (o UnmarshalOptions) unmarshalList(b []byte, wtyp protowire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
-	switch fd.Kind() {
-	case protoreflect.BoolKind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeVarint(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.VarintType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
-		return n, nil
-	case protoreflect.EnumKind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeVarint(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.VarintType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
-		return n, nil
-	case protoreflect.Int32Kind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeVarint(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfInt32(int32(v)))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.VarintType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfInt32(int32(v)))
-		return n, nil
-	case protoreflect.Sint32Kind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeVarint(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.VarintType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
-		return n, nil
-	case protoreflect.Uint32Kind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeVarint(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfUint32(uint32(v)))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.VarintType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfUint32(uint32(v)))
-		return n, nil
-	case protoreflect.Int64Kind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeVarint(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfInt64(int64(v)))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.VarintType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfInt64(int64(v)))
-		return n, nil
-	case protoreflect.Sint64Kind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeVarint(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.VarintType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
-		return n, nil
-	case protoreflect.Uint64Kind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeVarint(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfUint64(v))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.VarintType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeVarint(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfUint64(v))
-		return n, nil
-	case protoreflect.Sfixed32Kind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeFixed32(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfInt32(int32(v)))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.Fixed32Type {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed32(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfInt32(int32(v)))
-		return n, nil
-	case protoreflect.Fixed32Kind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeFixed32(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfUint32(uint32(v)))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.Fixed32Type {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed32(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfUint32(uint32(v)))
-		return n, nil
-	case protoreflect.FloatKind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeFixed32(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.Fixed32Type {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed32(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
-		return n, nil
-	case protoreflect.Sfixed64Kind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeFixed64(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfInt64(int64(v)))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.Fixed64Type {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed64(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfInt64(int64(v)))
-		return n, nil
-	case protoreflect.Fixed64Kind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeFixed64(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfUint64(v))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.Fixed64Type {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed64(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfUint64(v))
-		return n, nil
-	case protoreflect.DoubleKind:
-		if wtyp == protowire.BytesType {
-			buf, n := protowire.ConsumeBytes(b)
-			if n < 0 {
-				return 0, protowire.ParseError(n)
-			}
-			for len(buf) > 0 {
-				v, n := protowire.ConsumeFixed64(buf)
-				if n < 0 {
-					return 0, protowire.ParseError(n)
-				}
-				buf = buf[n:]
-				list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
-			}
-			return n, nil
-		}
-		if wtyp != protowire.Fixed64Type {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeFixed64(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
-		return n, nil
-	case protoreflect.StringKind:
-		if wtyp != protowire.BytesType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
-			return 0, errors.InvalidUTF8(string(fd.FullName()))
-		}
-		list.Append(protoreflect.ValueOfString(string(v)))
-		return n, nil
-	case protoreflect.BytesKind:
-		if wtyp != protowire.BytesType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
-		return n, nil
-	case protoreflect.MessageKind:
-		if wtyp != protowire.BytesType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeBytes(b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		m := list.NewElement()
-		if err := o.unmarshalMessage(v, m.Message()); err != nil {
-			return 0, err
-		}
-		list.Append(m)
-		return n, nil
-	case protoreflect.GroupKind:
-		if wtyp != protowire.StartGroupType {
-			return 0, errUnknown
-		}
-		v, n := protowire.ConsumeGroup(fd.Number(), b)
-		if n < 0 {
-			return 0, protowire.ParseError(n)
-		}
-		m := list.NewElement()
-		if err := o.unmarshalMessage(v, m.Message()); err != nil {
-			return 0, err
-		}
-		list.Append(m)
-		return n, nil
-	default:
-		return 0, errUnknown
-	}
-}
-
-// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
-var emptyBuf [0]byte
diff --git a/vendor/google.golang.org/protobuf/proto/doc.go b/vendor/google.golang.org/protobuf/proto/doc.go
deleted file mode 100644
index c52d8c4..0000000
--- a/vendor/google.golang.org/protobuf/proto/doc.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package proto provides functions operating on protocol buffer messages.
-//
-// For documentation on protocol buffers in general, see:
-//
-//   https://developers.google.com/protocol-buffers
-//
-// For a tutorial on using protocol buffers with Go, see:
-//
-//   https://developers.google.com/protocol-buffers/docs/gotutorial
-//
-// For a guide to generated Go protocol buffer code, see:
-//
-//   https://developers.google.com/protocol-buffers/docs/reference/go-generated
-//
-//
-// Binary serialization
-//
-// This package contains functions to convert to and from the wire format,
-// an efficient binary serialization of protocol buffers.
-//
-// • Size reports the size of a message in the wire format.
-//
-// • Marshal converts a message to the wire format.
-// The MarshalOptions type provides more control over wire marshaling.
-//
-// • Unmarshal converts a message from the wire format.
-// The UnmarshalOptions type provides more control over wire unmarshaling.
-//
-//
-// Basic message operations
-//
-// • Clone makes a deep copy of a message.
-//
-// • Merge merges the content of a message into another.
-//
-// • Equal compares two messages. For more control over comparisons
-// and detailed reporting of differences, see package
-// "google.golang.org/protobuf/testing/protocmp".
-//
-// • Reset clears the content of a message.
-//
-// • CheckInitialized reports whether all required fields in a message are set.
-//
-//
-// Optional scalar constructors
-//
-// The API for some generated messages represents optional scalar fields
-// as pointers to a value. For example, an optional string field has the
-// Go type *string.
-//
-// • Bool, Int32, Int64, Uint32, Uint64, Float32, Float64, and String
-// take a value and return a pointer to a new instance of it,
-// to simplify construction of optional field values.
-//
-// Generated enum types usually have an Enum method which performs the
-// same operation.
-//
-// Optional scalar fields are only supported in proto2.
-//
-//
-// Extension accessors
-//
-// • HasExtension, GetExtension, SetExtension, and ClearExtension
-// access extension field values in a protocol buffer message.
-//
-// Extension fields are only supported in proto2.
-//
-//
-// Related packages
-//
-// • Package "google.golang.org/protobuf/encoding/protojson" converts messages to
-// and from JSON.
-//
-// • Package "google.golang.org/protobuf/encoding/prototext" converts messages to
-// and from the text format.
-//
-// • Package "google.golang.org/protobuf/reflect/protoreflect" provides a
-// reflection interface for protocol buffer data types.
-//
-// • Package "google.golang.org/protobuf/testing/protocmp" provides features
-// to compare protocol buffer messages with the "github.com/google/go-cmp/cmp"
-// package.
-//
-// • Package "google.golang.org/protobuf/types/dynamicpb" provides a dynamic
-// message type, suitable for working with messages where the protocol buffer
-// type is only known at runtime.
-//
-// This module contains additional packages for more specialized use cases.
-// Consult the individual package documentation for details.
-package proto
diff --git a/vendor/google.golang.org/protobuf/proto/encode.go b/vendor/google.golang.org/protobuf/proto/encode.go
deleted file mode 100644
index 456bfda..0000000
--- a/vendor/google.golang.org/protobuf/proto/encode.go
+++ /dev/null
@@ -1,343 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"sort"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/fieldsort"
-	"google.golang.org/protobuf/internal/mapsort"
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoiface"
-)
-
-// MarshalOptions configures the marshaler.
-//
-// Example usage:
-//   b, err := MarshalOptions{Deterministic: true}.Marshal(m)
-type MarshalOptions struct {
-	pragma.NoUnkeyedLiterals
-
-	// AllowPartial allows messages that have missing required fields to marshal
-	// without returning an error. If AllowPartial is false (the default),
-	// Marshal will return an error if there are any missing required fields.
-	AllowPartial bool
-
-	// Deterministic controls whether the same message will always be
-	// serialized to the same bytes within the same binary.
-	//
-	// Setting this option guarantees that repeated serialization of
-	// the same message will return the same bytes, and that different
-	// processes of the same binary (which may be executing on different
-	// machines) will serialize equal messages to the same bytes.
-	// It has no effect on the resulting size of the encoded message compared
-	// to a non-deterministic marshal.
-	//
-	// Note that the deterministic serialization is NOT canonical across
-	// languages. It is not guaranteed to remain stable over time. It is
-	// unstable across different builds with schema changes due to unknown
-	// fields. Users who need canonical serialization (e.g., persistent
-	// storage in a canonical form, fingerprinting, etc.) must define
-	// their own canonicalization specification and implement their own
-	// serializer rather than relying on this API.
-	//
-	// If deterministic serialization is requested, map entries will be
-	// sorted by keys in lexographical order. This is an implementation
-	// detail and subject to change.
-	Deterministic bool
-
-	// UseCachedSize indicates that the result of a previous Size call
-	// may be reused.
-	//
-	// Setting this option asserts that:
-	//
-	// 1. Size has previously been called on this message with identical
-	// options (except for UseCachedSize itself).
-	//
-	// 2. The message and all its submessages have not changed in any
-	// way since the Size call.
-	//
-	// If either of these invariants is violated,
-	// the results are undefined and may include panics or corrupted output.
-	//
-	// Implementations MAY take this option into account to provide
-	// better performance, but there is no guarantee that they will do so.
-	// There is absolutely no guarantee that Size followed by Marshal with
-	// UseCachedSize set will perform equivalently to Marshal alone.
-	UseCachedSize bool
-}
-
-// Marshal returns the wire-format encoding of m.
-func Marshal(m Message) ([]byte, error) {
-	// Treat nil message interface as an empty message; nothing to output.
-	if m == nil {
-		return nil, nil
-	}
-
-	out, err := MarshalOptions{}.marshal(nil, m.ProtoReflect())
-	if len(out.Buf) == 0 && err == nil {
-		out.Buf = emptyBytesForMessage(m)
-	}
-	return out.Buf, err
-}
-
-// Marshal returns the wire-format encoding of m.
-func (o MarshalOptions) Marshal(m Message) ([]byte, error) {
-	// Treat nil message interface as an empty message; nothing to output.
-	if m == nil {
-		return nil, nil
-	}
-
-	out, err := o.marshal(nil, m.ProtoReflect())
-	if len(out.Buf) == 0 && err == nil {
-		out.Buf = emptyBytesForMessage(m)
-	}
-	return out.Buf, err
-}
-
-// emptyBytesForMessage returns a nil buffer if and only if m is invalid,
-// otherwise it returns a non-nil empty buffer.
-//
-// This is to assist the edge-case where user-code does the following:
-//	m1.OptionalBytes, _ = proto.Marshal(m2)
-// where they expect the proto2 "optional_bytes" field to be populated
-// if any only if m2 is a valid message.
-func emptyBytesForMessage(m Message) []byte {
-	if m == nil || !m.ProtoReflect().IsValid() {
-		return nil
-	}
-	return emptyBuf[:]
-}
-
-// MarshalAppend appends the wire-format encoding of m to b,
-// returning the result.
-func (o MarshalOptions) MarshalAppend(b []byte, m Message) ([]byte, error) {
-	// Treat nil message interface as an empty message; nothing to append.
-	if m == nil {
-		return b, nil
-	}
-
-	out, err := o.marshal(b, m.ProtoReflect())
-	return out.Buf, err
-}
-
-// MarshalState returns the wire-format encoding of a message.
-//
-// This method permits fine-grained control over the marshaler.
-// Most users should use Marshal instead.
-func (o MarshalOptions) MarshalState(in protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-	return o.marshal(in.Buf, in.Message)
-}
-
-func (o MarshalOptions) marshal(b []byte, m protoreflect.Message) (out protoiface.MarshalOutput, err error) {
-	allowPartial := o.AllowPartial
-	o.AllowPartial = true
-	if methods := protoMethods(m); methods != nil && methods.Marshal != nil &&
-		!(o.Deterministic && methods.Flags&protoiface.SupportMarshalDeterministic == 0) {
-		in := protoiface.MarshalInput{
-			Message: m,
-			Buf:     b,
-		}
-		if o.Deterministic {
-			in.Flags |= protoiface.MarshalDeterministic
-		}
-		if o.UseCachedSize {
-			in.Flags |= protoiface.MarshalUseCachedSize
-		}
-		if methods.Size != nil {
-			sout := methods.Size(protoiface.SizeInput{
-				Message: m,
-				Flags:   in.Flags,
-			})
-			if cap(b) < len(b)+sout.Size {
-				in.Buf = make([]byte, len(b), growcap(cap(b), len(b)+sout.Size))
-				copy(in.Buf, b)
-			}
-			in.Flags |= protoiface.MarshalUseCachedSize
-		}
-		out, err = methods.Marshal(in)
-	} else {
-		out.Buf, err = o.marshalMessageSlow(b, m)
-	}
-	if err != nil {
-		return out, err
-	}
-	if allowPartial {
-		return out, nil
-	}
-	return out, checkInitialized(m)
-}
-
-func (o MarshalOptions) marshalMessage(b []byte, m protoreflect.Message) ([]byte, error) {
-	out, err := o.marshal(b, m)
-	return out.Buf, err
-}
-
-// growcap scales up the capacity of a slice.
-//
-// Given a slice with a current capacity of oldcap and a desired
-// capacity of wantcap, growcap returns a new capacity >= wantcap.
-//
-// The algorithm is mostly identical to the one used by append as of Go 1.14.
-func growcap(oldcap, wantcap int) (newcap int) {
-	if wantcap > oldcap*2 {
-		newcap = wantcap
-	} else if oldcap < 1024 {
-		// The Go 1.14 runtime takes this case when len(s) < 1024,
-		// not when cap(s) < 1024. The difference doesn't seem
-		// significant here.
-		newcap = oldcap * 2
-	} else {
-		newcap = oldcap
-		for 0 < newcap && newcap < wantcap {
-			newcap += newcap / 4
-		}
-		if newcap <= 0 {
-			newcap = wantcap
-		}
-	}
-	return newcap
-}
-
-func (o MarshalOptions) marshalMessageSlow(b []byte, m protoreflect.Message) ([]byte, error) {
-	if messageset.IsMessageSet(m.Descriptor()) {
-		return marshalMessageSet(b, m, o)
-	}
-	// There are many choices for what order we visit fields in. The default one here
-	// is chosen for reasonable efficiency and simplicity given the protoreflect API.
-	// It is not deterministic, since Message.Range does not return fields in any
-	// defined order.
-	//
-	// When using deterministic serialization, we sort the known fields.
-	var err error
-	o.rangeFields(m, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		b, err = o.marshalField(b, fd, v)
-		return err == nil
-	})
-	if err != nil {
-		return b, err
-	}
-	b = append(b, m.GetUnknown()...)
-	return b, nil
-}
-
-// rangeFields visits fields in a defined order when deterministic serialization is enabled.
-func (o MarshalOptions) rangeFields(m protoreflect.Message, f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if !o.Deterministic {
-		m.Range(f)
-		return
-	}
-	var fds []protoreflect.FieldDescriptor
-	m.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
-		fds = append(fds, fd)
-		return true
-	})
-	sort.Slice(fds, func(a, b int) bool {
-		return fieldsort.Less(fds[a], fds[b])
-	})
-	for _, fd := range fds {
-		if !f(fd, m.Get(fd)) {
-			break
-		}
-	}
-}
-
-func (o MarshalOptions) marshalField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value) ([]byte, error) {
-	switch {
-	case fd.IsList():
-		return o.marshalList(b, fd, value.List())
-	case fd.IsMap():
-		return o.marshalMap(b, fd, value.Map())
-	default:
-		b = protowire.AppendTag(b, fd.Number(), wireTypes[fd.Kind()])
-		return o.marshalSingular(b, fd, value)
-	}
-}
-
-func (o MarshalOptions) marshalList(b []byte, fd protoreflect.FieldDescriptor, list protoreflect.List) ([]byte, error) {
-	if fd.IsPacked() && list.Len() > 0 {
-		b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
-		b, pos := appendSpeculativeLength(b)
-		for i, llen := 0, list.Len(); i < llen; i++ {
-			var err error
-			b, err = o.marshalSingular(b, fd, list.Get(i))
-			if err != nil {
-				return b, err
-			}
-		}
-		b = finishSpeculativeLength(b, pos)
-		return b, nil
-	}
-
-	kind := fd.Kind()
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		var err error
-		b = protowire.AppendTag(b, fd.Number(), wireTypes[kind])
-		b, err = o.marshalSingular(b, fd, list.Get(i))
-		if err != nil {
-			return b, err
-		}
-	}
-	return b, nil
-}
-
-func (o MarshalOptions) marshalMap(b []byte, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) ([]byte, error) {
-	keyf := fd.MapKey()
-	valf := fd.MapValue()
-	var err error
-	o.rangeMap(mapv, keyf.Kind(), func(key protoreflect.MapKey, value protoreflect.Value) bool {
-		b = protowire.AppendTag(b, fd.Number(), protowire.BytesType)
-		var pos int
-		b, pos = appendSpeculativeLength(b)
-
-		b, err = o.marshalField(b, keyf, key.Value())
-		if err != nil {
-			return false
-		}
-		b, err = o.marshalField(b, valf, value)
-		if err != nil {
-			return false
-		}
-		b = finishSpeculativeLength(b, pos)
-		return true
-	})
-	return b, err
-}
-
-func (o MarshalOptions) rangeMap(mapv protoreflect.Map, kind protoreflect.Kind, f func(protoreflect.MapKey, protoreflect.Value) bool) {
-	if !o.Deterministic {
-		mapv.Range(f)
-		return
-	}
-	mapsort.Range(mapv, kind, f)
-}
-
-// When encoding length-prefixed fields, we speculatively set aside some number of bytes
-// for the length, encode the data, and then encode the length (shifting the data if necessary
-// to make room).
-const speculativeLength = 1
-
-func appendSpeculativeLength(b []byte) ([]byte, int) {
-	pos := len(b)
-	b = append(b, "\x00\x00\x00\x00"[:speculativeLength]...)
-	return b, pos
-}
-
-func finishSpeculativeLength(b []byte, pos int) []byte {
-	mlen := len(b) - pos - speculativeLength
-	msiz := protowire.SizeVarint(uint64(mlen))
-	if msiz != speculativeLength {
-		for i := 0; i < msiz-speculativeLength; i++ {
-			b = append(b, 0)
-		}
-		copy(b[pos+msiz:], b[pos+speculativeLength:])
-		b = b[:pos+msiz+mlen]
-	}
-	protowire.AppendVarint(b[:pos], uint64(mlen))
-	return b
-}
diff --git a/vendor/google.golang.org/protobuf/proto/encode_gen.go b/vendor/google.golang.org/protobuf/proto/encode_gen.go
deleted file mode 100644
index 185dacf..0000000
--- a/vendor/google.golang.org/protobuf/proto/encode_gen.go
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package proto
-
-import (
-	"math"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/strs"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-var wireTypes = map[protoreflect.Kind]protowire.Type{
-	protoreflect.BoolKind:     protowire.VarintType,
-	protoreflect.EnumKind:     protowire.VarintType,
-	protoreflect.Int32Kind:    protowire.VarintType,
-	protoreflect.Sint32Kind:   protowire.VarintType,
-	protoreflect.Uint32Kind:   protowire.VarintType,
-	protoreflect.Int64Kind:    protowire.VarintType,
-	protoreflect.Sint64Kind:   protowire.VarintType,
-	protoreflect.Uint64Kind:   protowire.VarintType,
-	protoreflect.Sfixed32Kind: protowire.Fixed32Type,
-	protoreflect.Fixed32Kind:  protowire.Fixed32Type,
-	protoreflect.FloatKind:    protowire.Fixed32Type,
-	protoreflect.Sfixed64Kind: protowire.Fixed64Type,
-	protoreflect.Fixed64Kind:  protowire.Fixed64Type,
-	protoreflect.DoubleKind:   protowire.Fixed64Type,
-	protoreflect.StringKind:   protowire.BytesType,
-	protoreflect.BytesKind:    protowire.BytesType,
-	protoreflect.MessageKind:  protowire.BytesType,
-	protoreflect.GroupKind:    protowire.StartGroupType,
-}
-
-func (o MarshalOptions) marshalSingular(b []byte, fd protoreflect.FieldDescriptor, v protoreflect.Value) ([]byte, error) {
-	switch fd.Kind() {
-	case protoreflect.BoolKind:
-		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
-	case protoreflect.EnumKind:
-		b = protowire.AppendVarint(b, uint64(v.Enum()))
-	case protoreflect.Int32Kind:
-		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
-	case protoreflect.Sint32Kind:
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
-	case protoreflect.Uint32Kind:
-		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
-	case protoreflect.Int64Kind:
-		b = protowire.AppendVarint(b, uint64(v.Int()))
-	case protoreflect.Sint64Kind:
-		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
-	case protoreflect.Uint64Kind:
-		b = protowire.AppendVarint(b, v.Uint())
-	case protoreflect.Sfixed32Kind:
-		b = protowire.AppendFixed32(b, uint32(v.Int()))
-	case protoreflect.Fixed32Kind:
-		b = protowire.AppendFixed32(b, uint32(v.Uint()))
-	case protoreflect.FloatKind:
-		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
-	case protoreflect.Sfixed64Kind:
-		b = protowire.AppendFixed64(b, uint64(v.Int()))
-	case protoreflect.Fixed64Kind:
-		b = protowire.AppendFixed64(b, v.Uint())
-	case protoreflect.DoubleKind:
-		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
-	case protoreflect.StringKind:
-		if strs.EnforceUTF8(fd) && !utf8.ValidString(v.String()) {
-			return b, errors.InvalidUTF8(string(fd.FullName()))
-		}
-		b = protowire.AppendString(b, v.String())
-	case protoreflect.BytesKind:
-		b = protowire.AppendBytes(b, v.Bytes())
-	case protoreflect.MessageKind:
-		var pos int
-		var err error
-		b, pos = appendSpeculativeLength(b)
-		b, err = o.marshalMessage(b, v.Message())
-		if err != nil {
-			return b, err
-		}
-		b = finishSpeculativeLength(b, pos)
-	case protoreflect.GroupKind:
-		var err error
-		b, err = o.marshalMessage(b, v.Message())
-		if err != nil {
-			return b, err
-		}
-		b = protowire.AppendVarint(b, protowire.EncodeTag(fd.Number(), protowire.EndGroupType))
-	default:
-		return b, errors.New("invalid kind %v", fd.Kind())
-	}
-	return b, nil
-}
diff --git a/vendor/google.golang.org/protobuf/proto/equal.go b/vendor/google.golang.org/protobuf/proto/equal.go
deleted file mode 100644
index 10902bd..0000000
--- a/vendor/google.golang.org/protobuf/proto/equal.go
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"bytes"
-	"math"
-	"reflect"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	pref "google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Equal reports whether two messages are equal.
-// If two messages marshal to the same bytes under deterministic serialization,
-// then Equal is guaranteed to report true.
-//
-// Two messages are equal if they belong to the same message descriptor,
-// have the same set of populated known and extension field values,
-// and the same set of unknown fields values. If either of the top-level
-// messages are invalid, then Equal reports true only if both are invalid.
-//
-// Scalar values are compared with the equivalent of the == operator in Go,
-// except bytes values which are compared using bytes.Equal and
-// floating point values which specially treat NaNs as equal.
-// Message values are compared by recursively calling Equal.
-// Lists are equal if each element value is also equal.
-// Maps are equal if they have the same set of keys, where the pair of values
-// for each key is also equal.
-func Equal(x, y Message) bool {
-	if x == nil || y == nil {
-		return x == nil && y == nil
-	}
-	mx := x.ProtoReflect()
-	my := y.ProtoReflect()
-	if mx.IsValid() != my.IsValid() {
-		return false
-	}
-	return equalMessage(mx, my)
-}
-
-// equalMessage compares two messages.
-func equalMessage(mx, my pref.Message) bool {
-	if mx.Descriptor() != my.Descriptor() {
-		return false
-	}
-
-	nx := 0
-	equal := true
-	mx.Range(func(fd pref.FieldDescriptor, vx pref.Value) bool {
-		nx++
-		vy := my.Get(fd)
-		equal = my.Has(fd) && equalField(fd, vx, vy)
-		return equal
-	})
-	if !equal {
-		return false
-	}
-	ny := 0
-	my.Range(func(fd pref.FieldDescriptor, vx pref.Value) bool {
-		ny++
-		return true
-	})
-	if nx != ny {
-		return false
-	}
-
-	return equalUnknown(mx.GetUnknown(), my.GetUnknown())
-}
-
-// equalField compares two fields.
-func equalField(fd pref.FieldDescriptor, x, y pref.Value) bool {
-	switch {
-	case fd.IsList():
-		return equalList(fd, x.List(), y.List())
-	case fd.IsMap():
-		return equalMap(fd, x.Map(), y.Map())
-	default:
-		return equalValue(fd, x, y)
-	}
-}
-
-// equalMap compares two maps.
-func equalMap(fd pref.FieldDescriptor, x, y pref.Map) bool {
-	if x.Len() != y.Len() {
-		return false
-	}
-	equal := true
-	x.Range(func(k pref.MapKey, vx pref.Value) bool {
-		vy := y.Get(k)
-		equal = y.Has(k) && equalValue(fd.MapValue(), vx, vy)
-		return equal
-	})
-	return equal
-}
-
-// equalList compares two lists.
-func equalList(fd pref.FieldDescriptor, x, y pref.List) bool {
-	if x.Len() != y.Len() {
-		return false
-	}
-	for i := x.Len() - 1; i >= 0; i-- {
-		if !equalValue(fd, x.Get(i), y.Get(i)) {
-			return false
-		}
-	}
-	return true
-}
-
-// equalValue compares two singular values.
-func equalValue(fd pref.FieldDescriptor, x, y pref.Value) bool {
-	switch {
-	case fd.Message() != nil:
-		return equalMessage(x.Message(), y.Message())
-	case fd.Kind() == pref.BytesKind:
-		return bytes.Equal(x.Bytes(), y.Bytes())
-	case fd.Kind() == pref.FloatKind, fd.Kind() == pref.DoubleKind:
-		fx := x.Float()
-		fy := y.Float()
-		if math.IsNaN(fx) || math.IsNaN(fy) {
-			return math.IsNaN(fx) && math.IsNaN(fy)
-		}
-		return fx == fy
-	default:
-		return x.Interface() == y.Interface()
-	}
-}
-
-// equalUnknown compares unknown fields by direct comparison on the raw bytes
-// of each individual field number.
-func equalUnknown(x, y pref.RawFields) bool {
-	if len(x) != len(y) {
-		return false
-	}
-	if bytes.Equal([]byte(x), []byte(y)) {
-		return true
-	}
-
-	mx := make(map[pref.FieldNumber]pref.RawFields)
-	my := make(map[pref.FieldNumber]pref.RawFields)
-	for len(x) > 0 {
-		fnum, _, n := protowire.ConsumeField(x)
-		mx[fnum] = append(mx[fnum], x[:n]...)
-		x = x[n:]
-	}
-	for len(y) > 0 {
-		fnum, _, n := protowire.ConsumeField(y)
-		my[fnum] = append(my[fnum], y[:n]...)
-		y = y[n:]
-	}
-	return reflect.DeepEqual(mx, my)
-}
diff --git a/vendor/google.golang.org/protobuf/proto/extension.go b/vendor/google.golang.org/protobuf/proto/extension.go
deleted file mode 100644
index 5f293cd..0000000
--- a/vendor/google.golang.org/protobuf/proto/extension.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// HasExtension reports whether an extension field is populated.
-// It returns false if m is invalid or if xt does not extend m.
-func HasExtension(m Message, xt protoreflect.ExtensionType) bool {
-	// Treat nil message interface as an empty message; no populated fields.
-	if m == nil {
-		return false
-	}
-
-	// As a special-case, we reports invalid or mismatching descriptors
-	// as always not being populated (since they aren't).
-	if xt == nil || m.ProtoReflect().Descriptor() != xt.TypeDescriptor().ContainingMessage() {
-		return false
-	}
-
-	return m.ProtoReflect().Has(xt.TypeDescriptor())
-}
-
-// ClearExtension clears an extension field such that subsequent
-// HasExtension calls return false.
-// It panics if m is invalid or if xt does not extend m.
-func ClearExtension(m Message, xt protoreflect.ExtensionType) {
-	m.ProtoReflect().Clear(xt.TypeDescriptor())
-}
-
-// GetExtension retrieves the value for an extension field.
-// If the field is unpopulated, it returns the default value for
-// scalars and an immutable, empty value for lists or messages.
-// It panics if xt does not extend m.
-func GetExtension(m Message, xt protoreflect.ExtensionType) interface{} {
-	// Treat nil message interface as an empty message; return the default.
-	if m == nil {
-		return xt.InterfaceOf(xt.Zero())
-	}
-
-	return xt.InterfaceOf(m.ProtoReflect().Get(xt.TypeDescriptor()))
-}
-
-// SetExtension stores the value of an extension field.
-// It panics if m is invalid, xt does not extend m, or if type of v
-// is invalid for the specified extension field.
-func SetExtension(m Message, xt protoreflect.ExtensionType, v interface{}) {
-	xd := xt.TypeDescriptor()
-	pv := xt.ValueOf(v)
-
-	// Specially treat an invalid list, map, or message as clear.
-	isValid := true
-	switch {
-	case xd.IsList():
-		isValid = pv.List().IsValid()
-	case xd.IsMap():
-		isValid = pv.Map().IsValid()
-	case xd.Message() != nil:
-		isValid = pv.Message().IsValid()
-	}
-	if !isValid {
-		m.ProtoReflect().Clear(xd)
-		return
-	}
-
-	m.ProtoReflect().Set(xd, pv)
-}
-
-// RangeExtensions iterates over every populated extension field in m in an
-// undefined order, calling f for each extension type and value encountered.
-// It returns immediately if f returns false.
-// While iterating, mutating operations may only be performed
-// on the current extension field.
-func RangeExtensions(m Message, f func(protoreflect.ExtensionType, interface{}) bool) {
-	// Treat nil message interface as an empty message; nothing to range over.
-	if m == nil {
-		return
-	}
-
-	m.ProtoReflect().Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		if fd.IsExtension() {
-			xt := fd.(protoreflect.ExtensionTypeDescriptor).Type()
-			vi := xt.InterfaceOf(v)
-			return f(xt, vi)
-		}
-		return true
-	})
-}
diff --git a/vendor/google.golang.org/protobuf/proto/merge.go b/vendor/google.golang.org/protobuf/proto/merge.go
deleted file mode 100644
index d761ab3..0000000
--- a/vendor/google.golang.org/protobuf/proto/merge.go
+++ /dev/null
@@ -1,139 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"fmt"
-
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoiface"
-)
-
-// Merge merges src into dst, which must be a message with the same descriptor.
-//
-// Populated scalar fields in src are copied to dst, while populated
-// singular messages in src are merged into dst by recursively calling Merge.
-// The elements of every list field in src is appended to the corresponded
-// list fields in dst. The entries of every map field in src is copied into
-// the corresponding map field in dst, possibly replacing existing entries.
-// The unknown fields of src are appended to the unknown fields of dst.
-//
-// It is semantically equivalent to unmarshaling the encoded form of src
-// into dst with the UnmarshalOptions.Merge option specified.
-func Merge(dst, src Message) {
-	// TODO: Should nil src be treated as semantically equivalent to a
-	// untyped, read-only, empty message? What about a nil dst?
-
-	dstMsg, srcMsg := dst.ProtoReflect(), src.ProtoReflect()
-	if dstMsg.Descriptor() != srcMsg.Descriptor() {
-		if got, want := dstMsg.Descriptor().FullName(), srcMsg.Descriptor().FullName(); got != want {
-			panic(fmt.Sprintf("descriptor mismatch: %v != %v", got, want))
-		}
-		panic("descriptor mismatch")
-	}
-	mergeOptions{}.mergeMessage(dstMsg, srcMsg)
-}
-
-// Clone returns a deep copy of m.
-// If the top-level message is invalid, it returns an invalid message as well.
-func Clone(m Message) Message {
-	// NOTE: Most usages of Clone assume the following properties:
-	//	t := reflect.TypeOf(m)
-	//	t == reflect.TypeOf(m.ProtoReflect().New().Interface())
-	//	t == reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface())
-	//
-	// Embedding protobuf messages breaks this since the parent type will have
-	// a forwarded ProtoReflect method, but the Interface method will return
-	// the underlying embedded message type.
-	if m == nil {
-		return nil
-	}
-	src := m.ProtoReflect()
-	if !src.IsValid() {
-		return src.Type().Zero().Interface()
-	}
-	dst := src.New()
-	mergeOptions{}.mergeMessage(dst, src)
-	return dst.Interface()
-}
-
-// mergeOptions provides a namespace for merge functions, and can be
-// exported in the future if we add user-visible merge options.
-type mergeOptions struct{}
-
-func (o mergeOptions) mergeMessage(dst, src protoreflect.Message) {
-	methods := protoMethods(dst)
-	if methods != nil && methods.Merge != nil {
-		in := protoiface.MergeInput{
-			Destination: dst,
-			Source:      src,
-		}
-		out := methods.Merge(in)
-		if out.Flags&protoiface.MergeComplete != 0 {
-			return
-		}
-	}
-
-	if !dst.IsValid() {
-		panic(fmt.Sprintf("cannot merge into invalid %v message", dst.Descriptor().FullName()))
-	}
-
-	src.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		switch {
-		case fd.IsList():
-			o.mergeList(dst.Mutable(fd).List(), v.List(), fd)
-		case fd.IsMap():
-			o.mergeMap(dst.Mutable(fd).Map(), v.Map(), fd.MapValue())
-		case fd.Message() != nil:
-			o.mergeMessage(dst.Mutable(fd).Message(), v.Message())
-		case fd.Kind() == protoreflect.BytesKind:
-			dst.Set(fd, o.cloneBytes(v))
-		default:
-			dst.Set(fd, v)
-		}
-		return true
-	})
-
-	if len(src.GetUnknown()) > 0 {
-		dst.SetUnknown(append(dst.GetUnknown(), src.GetUnknown()...))
-	}
-}
-
-func (o mergeOptions) mergeList(dst, src protoreflect.List, fd protoreflect.FieldDescriptor) {
-	// Merge semantics appends to the end of the existing list.
-	for i, n := 0, src.Len(); i < n; i++ {
-		switch v := src.Get(i); {
-		case fd.Message() != nil:
-			dstv := dst.NewElement()
-			o.mergeMessage(dstv.Message(), v.Message())
-			dst.Append(dstv)
-		case fd.Kind() == protoreflect.BytesKind:
-			dst.Append(o.cloneBytes(v))
-		default:
-			dst.Append(v)
-		}
-	}
-}
-
-func (o mergeOptions) mergeMap(dst, src protoreflect.Map, fd protoreflect.FieldDescriptor) {
-	// Merge semantics replaces, rather than merges into existing entries.
-	src.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
-		switch {
-		case fd.Message() != nil:
-			dstv := dst.NewValue()
-			o.mergeMessage(dstv.Message(), v.Message())
-			dst.Set(k, dstv)
-		case fd.Kind() == protoreflect.BytesKind:
-			dst.Set(k, o.cloneBytes(v))
-		default:
-			dst.Set(k, v)
-		}
-		return true
-	})
-}
-
-func (o mergeOptions) cloneBytes(v protoreflect.Value) protoreflect.Value {
-	return protoreflect.ValueOfBytes(append([]byte{}, v.Bytes()...))
-}
diff --git a/vendor/google.golang.org/protobuf/proto/messageset.go b/vendor/google.golang.org/protobuf/proto/messageset.go
deleted file mode 100644
index b6b3de5..0000000
--- a/vendor/google.golang.org/protobuf/proto/messageset.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/internal/flags"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/reflect/protoregistry"
-)
-
-func sizeMessageSet(m protoreflect.Message) (size int) {
-	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		size += messageset.SizeField(fd.Number())
-		size += protowire.SizeTag(messageset.FieldMessage)
-		size += protowire.SizeBytes(sizeMessage(v.Message()))
-		return true
-	})
-	size += messageset.SizeUnknown(m.GetUnknown())
-	return size
-}
-
-func marshalMessageSet(b []byte, m protoreflect.Message, o MarshalOptions) ([]byte, error) {
-	if !flags.ProtoLegacy {
-		return b, errors.New("no support for message_set_wire_format")
-	}
-	var err error
-	o.rangeFields(m, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		b, err = marshalMessageSetField(b, fd, v, o)
-		return err == nil
-	})
-	if err != nil {
-		return b, err
-	}
-	return messageset.AppendUnknown(b, m.GetUnknown())
-}
-
-func marshalMessageSetField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value, o MarshalOptions) ([]byte, error) {
-	b = messageset.AppendFieldStart(b, fd.Number())
-	b = protowire.AppendTag(b, messageset.FieldMessage, protowire.BytesType)
-	b = protowire.AppendVarint(b, uint64(o.Size(value.Message().Interface())))
-	b, err := o.marshalMessage(b, value.Message())
-	if err != nil {
-		return b, err
-	}
-	b = messageset.AppendFieldEnd(b)
-	return b, nil
-}
-
-func unmarshalMessageSet(b []byte, m protoreflect.Message, o UnmarshalOptions) error {
-	if !flags.ProtoLegacy {
-		return errors.New("no support for message_set_wire_format")
-	}
-	return messageset.Unmarshal(b, false, func(num protowire.Number, v []byte) error {
-		err := unmarshalMessageSetField(m, num, v, o)
-		if err == errUnknown {
-			unknown := m.GetUnknown()
-			unknown = protowire.AppendTag(unknown, num, protowire.BytesType)
-			unknown = protowire.AppendBytes(unknown, v)
-			m.SetUnknown(unknown)
-			return nil
-		}
-		return err
-	})
-}
-
-func unmarshalMessageSetField(m protoreflect.Message, num protowire.Number, v []byte, o UnmarshalOptions) error {
-	md := m.Descriptor()
-	if !md.ExtensionRanges().Has(num) {
-		return errUnknown
-	}
-	xt, err := o.Resolver.FindExtensionByNumber(md.FullName(), num)
-	if err == protoregistry.NotFound {
-		return errUnknown
-	}
-	if err != nil {
-		return errors.New("%v: unable to resolve extension %v: %v", md.FullName(), num, err)
-	}
-	xd := xt.TypeDescriptor()
-	if err := o.unmarshalMessage(v, m.Mutable(xd).Message()); err != nil {
-		return err
-	}
-	return nil
-}
diff --git a/vendor/google.golang.org/protobuf/proto/proto.go b/vendor/google.golang.org/protobuf/proto/proto.go
deleted file mode 100644
index ca14b09..0000000
--- a/vendor/google.golang.org/protobuf/proto/proto.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Message is the top-level interface that all messages must implement.
-// It provides access to a reflective view of a message.
-// Any implementation of this interface may be used with all functions in the
-// protobuf module that accept a Message, except where otherwise specified.
-//
-// This is the v2 interface definition for protobuf messages.
-// The v1 interface definition is "github.com/golang/protobuf/proto".Message.
-//
-// To convert a v1 message to a v2 message,
-// use "github.com/golang/protobuf/proto".MessageV2.
-// To convert a v2 message to a v1 message,
-// use "github.com/golang/protobuf/proto".MessageV1.
-type Message = protoreflect.ProtoMessage
-
-// Error matches all errors produced by packages in the protobuf module.
-//
-// That is, errors.Is(err, Error) reports whether an error is produced
-// by this module.
-var Error error
-
-func init() {
-	Error = errors.Error
-}
diff --git a/vendor/google.golang.org/protobuf/proto/proto_methods.go b/vendor/google.golang.org/protobuf/proto/proto_methods.go
deleted file mode 100644
index d8dd604..0000000
--- a/vendor/google.golang.org/protobuf/proto/proto_methods.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// The protoreflect build tag disables use of fast-path methods.
-// +build !protoreflect
-
-package proto
-
-import (
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoiface"
-)
-
-const hasProtoMethods = true
-
-func protoMethods(m protoreflect.Message) *protoiface.Methods {
-	return m.ProtoMethods()
-}
diff --git a/vendor/google.golang.org/protobuf/proto/proto_reflect.go b/vendor/google.golang.org/protobuf/proto/proto_reflect.go
deleted file mode 100644
index b103d43..0000000
--- a/vendor/google.golang.org/protobuf/proto/proto_reflect.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// The protoreflect build tag disables use of fast-path methods.
-// +build protoreflect
-
-package proto
-
-import (
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoiface"
-)
-
-const hasProtoMethods = false
-
-func protoMethods(m protoreflect.Message) *protoiface.Methods {
-	return nil
-}
diff --git a/vendor/google.golang.org/protobuf/proto/reset.go b/vendor/google.golang.org/protobuf/proto/reset.go
deleted file mode 100644
index 3d7f894..0000000
--- a/vendor/google.golang.org/protobuf/proto/reset.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"fmt"
-
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Reset clears every field in the message.
-// The resulting message shares no observable memory with its previous state
-// other than the memory for the message itself.
-func Reset(m Message) {
-	if mr, ok := m.(interface{ Reset() }); ok && hasProtoMethods {
-		mr.Reset()
-		return
-	}
-	resetMessage(m.ProtoReflect())
-}
-
-func resetMessage(m protoreflect.Message) {
-	if !m.IsValid() {
-		panic(fmt.Sprintf("cannot reset invalid %v message", m.Descriptor().FullName()))
-	}
-
-	// Clear all known fields.
-	fds := m.Descriptor().Fields()
-	for i := 0; i < fds.Len(); i++ {
-		m.Clear(fds.Get(i))
-	}
-
-	// Clear extension fields.
-	m.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool {
-		m.Clear(fd)
-		return true
-	})
-
-	// Clear unknown fields.
-	m.SetUnknown(nil)
-}
diff --git a/vendor/google.golang.org/protobuf/proto/size.go b/vendor/google.golang.org/protobuf/proto/size.go
deleted file mode 100644
index 11ba841..0000000
--- a/vendor/google.golang.org/protobuf/proto/size.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-import (
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/encoding/messageset"
-	"google.golang.org/protobuf/reflect/protoreflect"
-	"google.golang.org/protobuf/runtime/protoiface"
-)
-
-// Size returns the size in bytes of the wire-format encoding of m.
-func Size(m Message) int {
-	return MarshalOptions{}.Size(m)
-}
-
-// Size returns the size in bytes of the wire-format encoding of m.
-func (o MarshalOptions) Size(m Message) int {
-	// Treat a nil message interface as an empty message; nothing to output.
-	if m == nil {
-		return 0
-	}
-
-	return sizeMessage(m.ProtoReflect())
-}
-
-func sizeMessage(m protoreflect.Message) (size int) {
-	methods := protoMethods(m)
-	if methods != nil && methods.Size != nil {
-		out := methods.Size(protoiface.SizeInput{
-			Message: m,
-		})
-		return out.Size
-	}
-	if methods != nil && methods.Marshal != nil {
-		// This is not efficient, but we don't have any choice.
-		// This case is mainly used for legacy types with a Marshal method.
-		out, _ := methods.Marshal(protoiface.MarshalInput{
-			Message: m,
-		})
-		return len(out.Buf)
-	}
-	return sizeMessageSlow(m)
-}
-
-func sizeMessageSlow(m protoreflect.Message) (size int) {
-	if messageset.IsMessageSet(m.Descriptor()) {
-		return sizeMessageSet(m)
-	}
-	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
-		size += sizeField(fd, v)
-		return true
-	})
-	size += len(m.GetUnknown())
-	return size
-}
-
-func sizeField(fd protoreflect.FieldDescriptor, value protoreflect.Value) (size int) {
-	num := fd.Number()
-	switch {
-	case fd.IsList():
-		return sizeList(num, fd, value.List())
-	case fd.IsMap():
-		return sizeMap(num, fd, value.Map())
-	default:
-		return protowire.SizeTag(num) + sizeSingular(num, fd.Kind(), value)
-	}
-}
-
-func sizeList(num protowire.Number, fd protoreflect.FieldDescriptor, list protoreflect.List) (size int) {
-	if fd.IsPacked() && list.Len() > 0 {
-		content := 0
-		for i, llen := 0, list.Len(); i < llen; i++ {
-			content += sizeSingular(num, fd.Kind(), list.Get(i))
-		}
-		return protowire.SizeTag(num) + protowire.SizeBytes(content)
-	}
-
-	for i, llen := 0, list.Len(); i < llen; i++ {
-		size += protowire.SizeTag(num) + sizeSingular(num, fd.Kind(), list.Get(i))
-	}
-	return size
-}
-
-func sizeMap(num protowire.Number, fd protoreflect.FieldDescriptor, mapv protoreflect.Map) (size int) {
-	mapv.Range(func(key protoreflect.MapKey, value protoreflect.Value) bool {
-		size += protowire.SizeTag(num)
-		size += protowire.SizeBytes(sizeField(fd.MapKey(), key.Value()) + sizeField(fd.MapValue(), value))
-		return true
-	})
-	return size
-}
diff --git a/vendor/google.golang.org/protobuf/proto/size_gen.go b/vendor/google.golang.org/protobuf/proto/size_gen.go
deleted file mode 100644
index 1118460..0000000
--- a/vendor/google.golang.org/protobuf/proto/size_gen.go
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate-types. DO NOT EDIT.
-
-package proto
-
-import (
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-func sizeSingular(num protowire.Number, kind protoreflect.Kind, v protoreflect.Value) int {
-	switch kind {
-	case protoreflect.BoolKind:
-		return protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
-	case protoreflect.EnumKind:
-		return protowire.SizeVarint(uint64(v.Enum()))
-	case protoreflect.Int32Kind:
-		return protowire.SizeVarint(uint64(int32(v.Int())))
-	case protoreflect.Sint32Kind:
-		return protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
-	case protoreflect.Uint32Kind:
-		return protowire.SizeVarint(uint64(uint32(v.Uint())))
-	case protoreflect.Int64Kind:
-		return protowire.SizeVarint(uint64(v.Int()))
-	case protoreflect.Sint64Kind:
-		return protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
-	case protoreflect.Uint64Kind:
-		return protowire.SizeVarint(v.Uint())
-	case protoreflect.Sfixed32Kind:
-		return protowire.SizeFixed32()
-	case protoreflect.Fixed32Kind:
-		return protowire.SizeFixed32()
-	case protoreflect.FloatKind:
-		return protowire.SizeFixed32()
-	case protoreflect.Sfixed64Kind:
-		return protowire.SizeFixed64()
-	case protoreflect.Fixed64Kind:
-		return protowire.SizeFixed64()
-	case protoreflect.DoubleKind:
-		return protowire.SizeFixed64()
-	case protoreflect.StringKind:
-		return protowire.SizeBytes(len(v.String()))
-	case protoreflect.BytesKind:
-		return protowire.SizeBytes(len(v.Bytes()))
-	case protoreflect.MessageKind:
-		return protowire.SizeBytes(sizeMessage(v.Message()))
-	case protoreflect.GroupKind:
-		return protowire.SizeGroup(num, sizeMessage(v.Message()))
-	default:
-		return 0
-	}
-}
diff --git a/vendor/google.golang.org/protobuf/proto/wrappers.go b/vendor/google.golang.org/protobuf/proto/wrappers.go
deleted file mode 100644
index 653b12c..0000000
--- a/vendor/google.golang.org/protobuf/proto/wrappers.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package proto
-
-// Bool stores v in a new bool value and returns a pointer to it.
-func Bool(v bool) *bool { return &v }
-
-// Int32 stores v in a new int32 value and returns a pointer to it.
-func Int32(v int32) *int32 { return &v }
-
-// Int64 stores v in a new int64 value and returns a pointer to it.
-func Int64(v int64) *int64 { return &v }
-
-// Float32 stores v in a new float32 value and returns a pointer to it.
-func Float32(v float32) *float32 { return &v }
-
-// Float64 stores v in a new float64 value and returns a pointer to it.
-func Float64(v float64) *float64 { return &v }
-
-// Uint32 stores v in a new uint32 value and returns a pointer to it.
-func Uint32(v uint32) *uint32 { return &v }
-
-// Uint64 stores v in a new uint64 value and returns a pointer to it.
-func Uint64(v uint64) *uint64 { return &v }
-
-// String stores v in a new string value and returns a pointer to it.
-func String(v string) *string { return &v }
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go
deleted file mode 100644
index 6be5d16..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/methods.go
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoreflect
-
-import (
-	"google.golang.org/protobuf/internal/pragma"
-)
-
-// The following types are used by the fast-path Message.ProtoMethods method.
-//
-// To avoid polluting the public protoreflect API with types used only by
-// low-level implementations, the canonical definitions of these types are
-// in the runtime/protoiface package. The definitions here and in protoiface
-// must be kept in sync.
-type (
-	methods = struct {
-		pragma.NoUnkeyedLiterals
-		Flags            supportFlags
-		Size             func(sizeInput) sizeOutput
-		Marshal          func(marshalInput) (marshalOutput, error)
-		Unmarshal        func(unmarshalInput) (unmarshalOutput, error)
-		Merge            func(mergeInput) mergeOutput
-		CheckInitialized func(checkInitializedInput) (checkInitializedOutput, error)
-	}
-	supportFlags = uint64
-	sizeInput    = struct {
-		pragma.NoUnkeyedLiterals
-		Message Message
-		Flags   uint8
-	}
-	sizeOutput = struct {
-		pragma.NoUnkeyedLiterals
-		Size int
-	}
-	marshalInput = struct {
-		pragma.NoUnkeyedLiterals
-		Message Message
-		Buf     []byte
-		Flags   uint8
-	}
-	marshalOutput = struct {
-		pragma.NoUnkeyedLiterals
-		Buf []byte
-	}
-	unmarshalInput = struct {
-		pragma.NoUnkeyedLiterals
-		Message  Message
-		Buf      []byte
-		Flags    uint8
-		Resolver interface {
-			FindExtensionByName(field FullName) (ExtensionType, error)
-			FindExtensionByNumber(message FullName, field FieldNumber) (ExtensionType, error)
-		}
-	}
-	unmarshalOutput = struct {
-		pragma.NoUnkeyedLiterals
-		Flags uint8
-	}
-	mergeInput = struct {
-		pragma.NoUnkeyedLiterals
-		Source      Message
-		Destination Message
-	}
-	mergeOutput = struct {
-		pragma.NoUnkeyedLiterals
-		Flags uint8
-	}
-	checkInitializedInput = struct {
-		pragma.NoUnkeyedLiterals
-		Message Message
-	}
-	checkInitializedOutput = struct {
-		pragma.NoUnkeyedLiterals
-	}
-)
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go
deleted file mode 100644
index b669a4e..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go
+++ /dev/null
@@ -1,478 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protoreflect provides interfaces to dynamically manipulate messages.
-//
-// This package includes type descriptors which describe the structure of types
-// defined in proto source files and value interfaces which provide the
-// ability to examine and manipulate the contents of messages.
-//
-//
-// Protocol Buffer Descriptors
-//
-// Protobuf descriptors (e.g., EnumDescriptor or MessageDescriptor)
-// are immutable objects that represent protobuf type information.
-// They are wrappers around the messages declared in descriptor.proto.
-// Protobuf descriptors alone lack any information regarding Go types.
-//
-// Enums and messages generated by this module implement Enum and ProtoMessage,
-// where the Descriptor and ProtoReflect.Descriptor accessors respectively
-// return the protobuf descriptor for the values.
-//
-// The protobuf descriptor interfaces are not meant to be implemented by
-// user code since they might need to be extended in the future to support
-// additions to the protobuf language.
-// The "google.golang.org/protobuf/reflect/protodesc" package converts between
-// google.protobuf.DescriptorProto messages and protobuf descriptors.
-//
-//
-// Go Type Descriptors
-//
-// A type descriptor (e.g., EnumType or MessageType) is a constructor for
-// a concrete Go type that represents the associated protobuf descriptor.
-// There is commonly a one-to-one relationship between protobuf descriptors and
-// Go type descriptors, but it can potentially be a one-to-many relationship.
-//
-// Enums and messages generated by this module implement Enum and ProtoMessage,
-// where the Type and ProtoReflect.Type accessors respectively
-// return the protobuf descriptor for the values.
-//
-// The "google.golang.org/protobuf/types/dynamicpb" package can be used to
-// create Go type descriptors from protobuf descriptors.
-//
-//
-// Value Interfaces
-//
-// The Enum and Message interfaces provide a reflective view over an
-// enum or message instance. For enums, it provides the ability to retrieve
-// the enum value number for any concrete enum type. For messages, it provides
-// the ability to access or manipulate fields of the message.
-//
-// To convert a proto.Message to a protoreflect.Message, use the
-// former's ProtoReflect method. Since the ProtoReflect method is new to the
-// v2 message interface, it may not be present on older message implementations.
-// The "github.com/golang/protobuf/proto".MessageReflect function can be used
-// to obtain a reflective view on older messages.
-//
-//
-// Relationships
-//
-// The following diagrams demonstrate the relationships between
-// various types declared in this package.
-//
-//
-//	                       ┌───────────────────────────────────┐
-//	                       V                                   │
-//	   ┌────────────── New(n) ─────────────┐                   │
-//	   │                                   │                   │
-//	   │      ┌──── Descriptor() ──┐       │  ┌── Number() ──┐ │
-//	   │      │                    V       V  │              V │
-//	╔════════════╗  ╔════════════════╗  ╔════════╗  ╔════════════╗
-//	║  EnumType  ║  ║ EnumDescriptor ║  ║  Enum  ║  ║ EnumNumber ║
-//	╚════════════╝  ╚════════════════╝  ╚════════╝  ╚════════════╝
-//	      Λ           Λ                   │ │
-//	      │           └─── Descriptor() ──┘ │
-//	      │                                 │
-//	      └────────────────── Type() ───────┘
-//
-// • An EnumType describes a concrete Go enum type.
-// It has an EnumDescriptor and can construct an Enum instance.
-//
-// • An EnumDescriptor describes an abstract protobuf enum type.
-//
-// • An Enum is a concrete enum instance. Generated enums implement Enum.
-//
-//
-//	  ┌──────────────── New() ─────────────────┐
-//	  │                                        │
-//	  │         ┌─── Descriptor() ─────┐       │   ┌── Interface() ───┐
-//	  │         │                      V       V   │                  V
-//	╔═════════════╗  ╔═══════════════════╗  ╔═════════╗  ╔══════════════╗
-//	║ MessageType ║  ║ MessageDescriptor ║  ║ Message ║  ║ ProtoMessage ║
-//	╚═════════════╝  ╚═══════════════════╝  ╚═════════╝  ╚══════════════╝
-//	       Λ           Λ                      │ │  Λ                  │
-//	       │           └──── Descriptor() ────┘ │  └─ ProtoReflect() ─┘
-//	       │                                    │
-//	       └─────────────────── Type() ─────────┘
-//
-// • A MessageType describes a concrete Go message type.
-// It has a MessageDescriptor and can construct a Message instance.
-//
-// • A MessageDescriptor describes an abstract protobuf message type.
-//
-// • A Message is a concrete message instance. Generated messages implement
-// ProtoMessage, which can convert to/from a Message.
-//
-//
-//	      ┌── TypeDescriptor() ──┐    ┌───── Descriptor() ─────┐
-//	      │                      V    │                        V
-//	╔═══════════════╗  ╔═════════════════════════╗  ╔═════════════════════╗
-//	║ ExtensionType ║  ║ ExtensionTypeDescriptor ║  ║ ExtensionDescriptor ║
-//	╚═══════════════╝  ╚═════════════════════════╝  ╚═════════════════════╝
-//	      Λ                      │   │ Λ                      │ Λ
-//	      └─────── Type() ───────┘   │ └─── may implement ────┘ │
-//	                                 │                          │
-//	                                 └────── implements ────────┘
-//
-// • An ExtensionType describes a concrete Go implementation of an extension.
-// It has an ExtensionTypeDescriptor and can convert to/from
-// abstract Values and Go values.
-//
-// • An ExtensionTypeDescriptor is an ExtensionDescriptor
-// which also has an ExtensionType.
-//
-// • An ExtensionDescriptor describes an abstract protobuf extension field and
-// may not always be an ExtensionTypeDescriptor.
-package protoreflect
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-
-	"google.golang.org/protobuf/encoding/protowire"
-	"google.golang.org/protobuf/internal/pragma"
-)
-
-type doNotImplement pragma.DoNotImplement
-
-// ProtoMessage is the top-level interface that all proto messages implement.
-// This is declared in the protoreflect package to avoid a cyclic dependency;
-// use the proto.Message type instead, which aliases this type.
-type ProtoMessage interface{ ProtoReflect() Message }
-
-// Syntax is the language version of the proto file.
-type Syntax syntax
-
-type syntax int8 // keep exact type opaque as the int type may change
-
-const (
-	Proto2 Syntax = 2
-	Proto3 Syntax = 3
-)
-
-// IsValid reports whether the syntax is valid.
-func (s Syntax) IsValid() bool {
-	switch s {
-	case Proto2, Proto3:
-		return true
-	default:
-		return false
-	}
-}
-
-// String returns s as a proto source identifier (e.g., "proto2").
-func (s Syntax) String() string {
-	switch s {
-	case Proto2:
-		return "proto2"
-	case Proto3:
-		return "proto3"
-	default:
-		return fmt.Sprintf("<unknown:%d>", s)
-	}
-}
-
-// GoString returns s as a Go source identifier (e.g., "Proto2").
-func (s Syntax) GoString() string {
-	switch s {
-	case Proto2:
-		return "Proto2"
-	case Proto3:
-		return "Proto3"
-	default:
-		return fmt.Sprintf("Syntax(%d)", s)
-	}
-}
-
-// Cardinality determines whether a field is optional, required, or repeated.
-type Cardinality cardinality
-
-type cardinality int8 // keep exact type opaque as the int type may change
-
-// Constants as defined by the google.protobuf.Cardinality enumeration.
-const (
-	Optional Cardinality = 1 // appears zero or one times
-	Required Cardinality = 2 // appears exactly one time; invalid with Proto3
-	Repeated Cardinality = 3 // appears zero or more times
-)
-
-// IsValid reports whether the cardinality is valid.
-func (c Cardinality) IsValid() bool {
-	switch c {
-	case Optional, Required, Repeated:
-		return true
-	default:
-		return false
-	}
-}
-
-// String returns c as a proto source identifier (e.g., "optional").
-func (c Cardinality) String() string {
-	switch c {
-	case Optional:
-		return "optional"
-	case Required:
-		return "required"
-	case Repeated:
-		return "repeated"
-	default:
-		return fmt.Sprintf("<unknown:%d>", c)
-	}
-}
-
-// GoString returns c as a Go source identifier (e.g., "Optional").
-func (c Cardinality) GoString() string {
-	switch c {
-	case Optional:
-		return "Optional"
-	case Required:
-		return "Required"
-	case Repeated:
-		return "Repeated"
-	default:
-		return fmt.Sprintf("Cardinality(%d)", c)
-	}
-}
-
-// Kind indicates the basic proto kind of a field.
-type Kind kind
-
-type kind int8 // keep exact type opaque as the int type may change
-
-// Constants as defined by the google.protobuf.Field.Kind enumeration.
-const (
-	BoolKind     Kind = 8
-	EnumKind     Kind = 14
-	Int32Kind    Kind = 5
-	Sint32Kind   Kind = 17
-	Uint32Kind   Kind = 13
-	Int64Kind    Kind = 3
-	Sint64Kind   Kind = 18
-	Uint64Kind   Kind = 4
-	Sfixed32Kind Kind = 15
-	Fixed32Kind  Kind = 7
-	FloatKind    Kind = 2
-	Sfixed64Kind Kind = 16
-	Fixed64Kind  Kind = 6
-	DoubleKind   Kind = 1
-	StringKind   Kind = 9
-	BytesKind    Kind = 12
-	MessageKind  Kind = 11
-	GroupKind    Kind = 10
-)
-
-// IsValid reports whether the kind is valid.
-func (k Kind) IsValid() bool {
-	switch k {
-	case BoolKind, EnumKind,
-		Int32Kind, Sint32Kind, Uint32Kind,
-		Int64Kind, Sint64Kind, Uint64Kind,
-		Sfixed32Kind, Fixed32Kind, FloatKind,
-		Sfixed64Kind, Fixed64Kind, DoubleKind,
-		StringKind, BytesKind, MessageKind, GroupKind:
-		return true
-	default:
-		return false
-	}
-}
-
-// String returns k as a proto source identifier (e.g., "bool").
-func (k Kind) String() string {
-	switch k {
-	case BoolKind:
-		return "bool"
-	case EnumKind:
-		return "enum"
-	case Int32Kind:
-		return "int32"
-	case Sint32Kind:
-		return "sint32"
-	case Uint32Kind:
-		return "uint32"
-	case Int64Kind:
-		return "int64"
-	case Sint64Kind:
-		return "sint64"
-	case Uint64Kind:
-		return "uint64"
-	case Sfixed32Kind:
-		return "sfixed32"
-	case Fixed32Kind:
-		return "fixed32"
-	case FloatKind:
-		return "float"
-	case Sfixed64Kind:
-		return "sfixed64"
-	case Fixed64Kind:
-		return "fixed64"
-	case DoubleKind:
-		return "double"
-	case StringKind:
-		return "string"
-	case BytesKind:
-		return "bytes"
-	case MessageKind:
-		return "message"
-	case GroupKind:
-		return "group"
-	default:
-		return fmt.Sprintf("<unknown:%d>", k)
-	}
-}
-
-// GoString returns k as a Go source identifier (e.g., "BoolKind").
-func (k Kind) GoString() string {
-	switch k {
-	case BoolKind:
-		return "BoolKind"
-	case EnumKind:
-		return "EnumKind"
-	case Int32Kind:
-		return "Int32Kind"
-	case Sint32Kind:
-		return "Sint32Kind"
-	case Uint32Kind:
-		return "Uint32Kind"
-	case Int64Kind:
-		return "Int64Kind"
-	case Sint64Kind:
-		return "Sint64Kind"
-	case Uint64Kind:
-		return "Uint64Kind"
-	case Sfixed32Kind:
-		return "Sfixed32Kind"
-	case Fixed32Kind:
-		return "Fixed32Kind"
-	case FloatKind:
-		return "FloatKind"
-	case Sfixed64Kind:
-		return "Sfixed64Kind"
-	case Fixed64Kind:
-		return "Fixed64Kind"
-	case DoubleKind:
-		return "DoubleKind"
-	case StringKind:
-		return "StringKind"
-	case BytesKind:
-		return "BytesKind"
-	case MessageKind:
-		return "MessageKind"
-	case GroupKind:
-		return "GroupKind"
-	default:
-		return fmt.Sprintf("Kind(%d)", k)
-	}
-}
-
-// FieldNumber is the field number in a message.
-type FieldNumber = protowire.Number
-
-// FieldNumbers represent a list of field numbers.
-type FieldNumbers interface {
-	// Len reports the number of fields in the list.
-	Len() int
-	// Get returns the ith field number. It panics if out of bounds.
-	Get(i int) FieldNumber
-	// Has reports whether n is within the list of fields.
-	Has(n FieldNumber) bool
-
-	doNotImplement
-}
-
-// FieldRanges represent a list of field number ranges.
-type FieldRanges interface {
-	// Len reports the number of ranges in the list.
-	Len() int
-	// Get returns the ith range. It panics if out of bounds.
-	Get(i int) [2]FieldNumber // start inclusive; end exclusive
-	// Has reports whether n is within any of the ranges.
-	Has(n FieldNumber) bool
-
-	doNotImplement
-}
-
-// EnumNumber is the numeric value for an enum.
-type EnumNumber int32
-
-// EnumRanges represent a list of enum number ranges.
-type EnumRanges interface {
-	// Len reports the number of ranges in the list.
-	Len() int
-	// Get returns the ith range. It panics if out of bounds.
-	Get(i int) [2]EnumNumber // start inclusive; end inclusive
-	// Has reports whether n is within any of the ranges.
-	Has(n EnumNumber) bool
-
-	doNotImplement
-}
-
-var (
-	regexName     = regexp.MustCompile(`^[_a-zA-Z][_a-zA-Z0-9]*$`)
-	regexFullName = regexp.MustCompile(`^[_a-zA-Z][_a-zA-Z0-9]*(\.[_a-zA-Z][_a-zA-Z0-9]*)*$`)
-)
-
-// Name is the short name for a proto declaration. This is not the name
-// as used in Go source code, which might not be identical to the proto name.
-type Name string // e.g., "Kind"
-
-// IsValid reports whether n is a syntactically valid name.
-// An empty name is invalid.
-func (n Name) IsValid() bool {
-	return regexName.MatchString(string(n))
-}
-
-// Names represent a list of names.
-type Names interface {
-	// Len reports the number of names in the list.
-	Len() int
-	// Get returns the ith name. It panics if out of bounds.
-	Get(i int) Name
-	// Has reports whether s matches any names in the list.
-	Has(s Name) bool
-
-	doNotImplement
-}
-
-// FullName is a qualified name that uniquely identifies a proto declaration.
-// A qualified name is the concatenation of the proto package along with the
-// fully-declared name (i.e., name of parent preceding the name of the child),
-// with a '.' delimiter placed between each Name.
-//
-// This should not have any leading or trailing dots.
-type FullName string // e.g., "google.protobuf.Field.Kind"
-
-// IsValid reports whether n is a syntactically valid full name.
-// An empty full name is invalid.
-func (n FullName) IsValid() bool {
-	return regexFullName.MatchString(string(n))
-}
-
-// Name returns the short name, which is the last identifier segment.
-// A single segment FullName is the Name itself.
-func (n FullName) Name() Name {
-	if i := strings.LastIndexByte(string(n), '.'); i >= 0 {
-		return Name(n[i+1:])
-	}
-	return Name(n)
-}
-
-// Parent returns the full name with the trailing identifier removed.
-// A single segment FullName has no parent.
-func (n FullName) Parent() FullName {
-	if i := strings.LastIndexByte(string(n), '.'); i >= 0 {
-		return n[:i]
-	}
-	return ""
-}
-
-// Append returns the qualified name appended with the provided short name.
-//
-// Invariant: n == n.Parent().Append(n.Name()) // assuming n is valid
-func (n FullName) Append(s Name) FullName {
-	if n == "" {
-		return FullName(s)
-	}
-	return n + "." + FullName(s)
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/source.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/source.go
deleted file mode 100644
index 32ea3d9..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/source.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoreflect
-
-// SourceLocations is a list of source locations.
-type SourceLocations interface {
-	// Len reports the number of source locations in the proto file.
-	Len() int
-	// Get returns the ith SourceLocation. It panics if out of bounds.
-	Get(int) SourceLocation
-
-	doNotImplement
-
-	// TODO: Add ByPath and ByDescriptor helper methods.
-}
-
-// SourceLocation describes a source location and
-// corresponds with the google.protobuf.SourceCodeInfo.Location message.
-type SourceLocation struct {
-	// Path is the path to the declaration from the root file descriptor.
-	// The contents of this slice must not be mutated.
-	Path SourcePath
-
-	// StartLine and StartColumn are the zero-indexed starting location
-	// in the source file for the declaration.
-	StartLine, StartColumn int
-	// EndLine and EndColumn are the zero-indexed ending location
-	// in the source file for the declaration.
-	// In the descriptor.proto, the end line may be omitted if it is identical
-	// to the start line. Here, it is always populated.
-	EndLine, EndColumn int
-
-	// LeadingDetachedComments are the leading detached comments
-	// for the declaration. The contents of this slice must not be mutated.
-	LeadingDetachedComments []string
-	// LeadingComments is the leading attached comment for the declaration.
-	LeadingComments string
-	// TrailingComments is the trailing attached comment for the declaration.
-	TrailingComments string
-}
-
-// SourcePath identifies part of a file descriptor for a source location.
-// The SourcePath is a sequence of either field numbers or indexes into
-// a repeated field that form a path starting from the root file descriptor.
-//
-// See google.protobuf.SourceCodeInfo.Location.path.
-type SourcePath []int32
-
-// TODO: Add SourcePath.String method to pretty-print the path. For example:
-//	".message_type[6].nested_type[15].field[3]"
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go
deleted file mode 100644
index 5be14a7..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go
+++ /dev/null
@@ -1,631 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoreflect
-
-// Descriptor provides a set of accessors that are common to every descriptor.
-// Each descriptor type wraps the equivalent google.protobuf.XXXDescriptorProto,
-// but provides efficient lookup and immutability.
-//
-// Each descriptor is comparable. Equality implies that the two types are
-// exactly identical. However, it is possible for the same semantically
-// identical proto type to be represented by multiple type descriptors.
-//
-// For example, suppose we have t1 and t2 which are both MessageDescriptors.
-// If t1 == t2, then the types are definitely equal and all accessors return
-// the same information. However, if t1 != t2, then it is still possible that
-// they still represent the same proto type (e.g., t1.FullName == t2.FullName).
-// This can occur if a descriptor type is created dynamically, or multiple
-// versions of the same proto type are accidentally linked into the Go binary.
-type Descriptor interface {
-	// ParentFile returns the parent file descriptor that this descriptor
-	// is declared within. The parent file for the file descriptor is itself.
-	//
-	// Support for this functionality is optional and may return nil.
-	ParentFile() FileDescriptor
-
-	// Parent returns the parent containing this descriptor declaration.
-	// The following shows the mapping from child type to possible parent types:
-	//
-	//	╔═════════════════════╤═══════════════════════════════════╗
-	//	║ Child type          │ Possible parent types             ║
-	//	╠═════════════════════╪═══════════════════════════════════╣
-	//	║ FileDescriptor      │ nil                               ║
-	//	║ MessageDescriptor   │ FileDescriptor, MessageDescriptor ║
-	//	║ FieldDescriptor     │ FileDescriptor, MessageDescriptor ║
-	//	║ OneofDescriptor     │ MessageDescriptor                 ║
-	//	║ EnumDescriptor      │ FileDescriptor, MessageDescriptor ║
-	//	║ EnumValueDescriptor │ EnumDescriptor                    ║
-	//	║ ServiceDescriptor   │ FileDescriptor                    ║
-	//	║ MethodDescriptor    │ ServiceDescriptor                 ║
-	//	╚═════════════════════╧═══════════════════════════════════╝
-	//
-	// Support for this functionality is optional and may return nil.
-	Parent() Descriptor
-
-	// Index returns the index of this descriptor within its parent.
-	// It returns 0 if the descriptor does not have a parent or if the parent
-	// is unknown.
-	Index() int
-
-	// Syntax is the protobuf syntax.
-	Syntax() Syntax // e.g., Proto2 or Proto3
-
-	// Name is the short name of the declaration (i.e., FullName.Name).
-	Name() Name // e.g., "Any"
-
-	// FullName is the fully-qualified name of the declaration.
-	//
-	// The FullName is a concatenation of the full name of the type that this
-	// type is declared within and the declaration name. For example,
-	// field "foo_field" in message "proto.package.MyMessage" is
-	// uniquely identified as "proto.package.MyMessage.foo_field".
-	// Enum values are an exception to the rule (see EnumValueDescriptor).
-	FullName() FullName // e.g., "google.protobuf.Any"
-
-	// IsPlaceholder reports whether type information is missing since a
-	// dependency is not resolved, in which case only name information is known.
-	//
-	// Placeholder types may only be returned by the following accessors
-	// as a result of unresolved dependencies or weak imports:
-	//
-	//	╔═══════════════════════════════════╤═════════════════════╗
-	//	║ Accessor                          │ Descriptor          ║
-	//	╠═══════════════════════════════════╪═════════════════════╣
-	//	║ FileImports.FileDescriptor        │ FileDescriptor      ║
-	//	║ FieldDescriptor.Enum              │ EnumDescriptor      ║
-	//	║ FieldDescriptor.Message           │ MessageDescriptor   ║
-	//	║ FieldDescriptor.DefaultEnumValue  │ EnumValueDescriptor ║
-	//	║ FieldDescriptor.ContainingMessage │ MessageDescriptor   ║
-	//	║ MethodDescriptor.Input            │ MessageDescriptor   ║
-	//	║ MethodDescriptor.Output           │ MessageDescriptor   ║
-	//	╚═══════════════════════════════════╧═════════════════════╝
-	//
-	// If true, only Name and FullName are valid.
-	// For FileDescriptor, the Path is also valid.
-	IsPlaceholder() bool
-
-	// Options returns the descriptor options. The caller must not modify
-	// the returned value.
-	//
-	// To avoid a dependency cycle, this function returns a proto.Message value.
-	// The proto message type returned for each descriptor type is as follows:
-	//	╔═════════════════════╤══════════════════════════════════════════╗
-	//	║ Go type             │ Protobuf message type                    ║
-	//	╠═════════════════════╪══════════════════════════════════════════╣
-	//	║ FileDescriptor      │ google.protobuf.FileOptions              ║
-	//	║ EnumDescriptor      │ google.protobuf.EnumOptions              ║
-	//	║ EnumValueDescriptor │ google.protobuf.EnumValueOptions         ║
-	//	║ MessageDescriptor   │ google.protobuf.MessageOptions           ║
-	//	║ FieldDescriptor     │ google.protobuf.FieldOptions             ║
-	//	║ OneofDescriptor     │ google.protobuf.OneofOptions             ║
-	//	║ ServiceDescriptor   │ google.protobuf.ServiceOptions           ║
-	//	║ MethodDescriptor    │ google.protobuf.MethodOptions            ║
-	//	╚═════════════════════╧══════════════════════════════════════════╝
-	//
-	// This method returns a typed nil-pointer if no options are present.
-	// The caller must import the descriptorpb package to use this.
-	Options() ProtoMessage
-
-	doNotImplement
-}
-
-// FileDescriptor describes the types in a complete proto file and
-// corresponds with the google.protobuf.FileDescriptorProto message.
-//
-// Top-level declarations:
-// EnumDescriptor, MessageDescriptor, FieldDescriptor, and/or ServiceDescriptor.
-type FileDescriptor interface {
-	Descriptor // Descriptor.FullName is identical to Package
-
-	// Path returns the file name, relative to the source tree root.
-	Path() string // e.g., "path/to/file.proto"
-	// Package returns the protobuf package namespace.
-	Package() FullName // e.g., "google.protobuf"
-
-	// Imports is a list of imported proto files.
-	Imports() FileImports
-
-	// Enums is a list of the top-level enum declarations.
-	Enums() EnumDescriptors
-	// Messages is a list of the top-level message declarations.
-	Messages() MessageDescriptors
-	// Extensions is a list of the top-level extension declarations.
-	Extensions() ExtensionDescriptors
-	// Services is a list of the top-level service declarations.
-	Services() ServiceDescriptors
-
-	// SourceLocations is a list of source locations.
-	SourceLocations() SourceLocations
-
-	isFileDescriptor
-}
-type isFileDescriptor interface{ ProtoType(FileDescriptor) }
-
-// FileImports is a list of file imports.
-type FileImports interface {
-	// Len reports the number of files imported by this proto file.
-	Len() int
-	// Get returns the ith FileImport. It panics if out of bounds.
-	Get(i int) FileImport
-
-	doNotImplement
-}
-
-// FileImport is the declaration for a proto file import.
-type FileImport struct {
-	// FileDescriptor is the file type for the given import.
-	// It is a placeholder descriptor if IsWeak is set or if a dependency has
-	// not been regenerated to implement the new reflection APIs.
-	FileDescriptor
-
-	// IsPublic reports whether this is a public import, which causes this file
-	// to alias declarations within the imported file. The intended use cases
-	// for this feature is the ability to move proto files without breaking
-	// existing dependencies.
-	//
-	// The current file and the imported file must be within proto package.
-	IsPublic bool
-
-	// IsWeak reports whether this is a weak import, which does not impose
-	// a direct dependency on the target file.
-	//
-	// Weak imports are a legacy proto1 feature. Equivalent behavior is
-	// achieved using proto2 extension fields or proto3 Any messages.
-	IsWeak bool
-}
-
-// MessageDescriptor describes a message and
-// corresponds with the google.protobuf.DescriptorProto message.
-//
-// Nested declarations:
-// FieldDescriptor, OneofDescriptor, FieldDescriptor, EnumDescriptor,
-// and/or MessageDescriptor.
-type MessageDescriptor interface {
-	Descriptor
-
-	// IsMapEntry indicates that this is an auto-generated message type to
-	// represent the entry type for a map field.
-	//
-	// Map entry messages have only two fields:
-	//	• a "key" field with a field number of 1
-	//	• a "value" field with a field number of 2
-	// The key and value types are determined by these two fields.
-	//
-	// If IsMapEntry is true, it implies that FieldDescriptor.IsMap is true
-	// for some field with this message type.
-	IsMapEntry() bool
-
-	// Fields is a list of nested field declarations.
-	Fields() FieldDescriptors
-	// Oneofs is a list of nested oneof declarations.
-	Oneofs() OneofDescriptors
-
-	// ReservedNames is a list of reserved field names.
-	ReservedNames() Names
-	// ReservedRanges is a list of reserved ranges of field numbers.
-	ReservedRanges() FieldRanges
-	// RequiredNumbers is a list of required field numbers.
-	// In Proto3, it is always an empty list.
-	RequiredNumbers() FieldNumbers
-	// ExtensionRanges is the field ranges used for extension fields.
-	// In Proto3, it is always an empty ranges.
-	ExtensionRanges() FieldRanges
-	// ExtensionRangeOptions returns the ith extension range options.
-	//
-	// To avoid a dependency cycle, this method returns a proto.Message value,
-	// which always contains a google.protobuf.ExtensionRangeOptions message.
-	// This method returns a typed nil-pointer if no options are present.
-	// The caller must import the descriptorpb package to use this.
-	ExtensionRangeOptions(i int) ProtoMessage
-
-	// Enums is a list of nested enum declarations.
-	Enums() EnumDescriptors
-	// Messages is a list of nested message declarations.
-	Messages() MessageDescriptors
-	// Extensions is a list of nested extension declarations.
-	Extensions() ExtensionDescriptors
-
-	isMessageDescriptor
-}
-type isMessageDescriptor interface{ ProtoType(MessageDescriptor) }
-
-// MessageType encapsulates a MessageDescriptor with a concrete Go implementation.
-type MessageType interface {
-	// New returns a newly allocated empty message.
-	New() Message
-
-	// Zero returns an empty, read-only message.
-	Zero() Message
-
-	// Descriptor returns the message descriptor.
-	//
-	// Invariant: t.Descriptor() == t.New().Descriptor()
-	Descriptor() MessageDescriptor
-}
-
-// MessageDescriptors is a list of message declarations.
-type MessageDescriptors interface {
-	// Len reports the number of messages.
-	Len() int
-	// Get returns the ith MessageDescriptor. It panics if out of bounds.
-	Get(i int) MessageDescriptor
-	// ByName returns the MessageDescriptor for a message named s.
-	// It returns nil if not found.
-	ByName(s Name) MessageDescriptor
-
-	doNotImplement
-}
-
-// FieldDescriptor describes a field within a message and
-// corresponds with the google.protobuf.FieldDescriptorProto message.
-//
-// It is used for both normal fields defined within the parent message
-// (e.g., MessageDescriptor.Fields) and fields that extend some remote message
-// (e.g., FileDescriptor.Extensions or MessageDescriptor.Extensions).
-type FieldDescriptor interface {
-	Descriptor
-
-	// Number reports the unique number for this field.
-	Number() FieldNumber
-	// Cardinality reports the cardinality for this field.
-	Cardinality() Cardinality
-	// Kind reports the basic kind for this field.
-	Kind() Kind
-
-	// HasJSONName reports whether this field has an explicitly set JSON name.
-	HasJSONName() bool
-
-	// JSONName reports the name used for JSON serialization.
-	// It is usually the camel-cased form of the field name.
-	JSONName() string
-
-	// HasPresence reports whether the field distinguishes between unpopulated
-	// and default values.
-	HasPresence() bool
-
-	// IsExtension reports whether this is an extension field. If false,
-	// then Parent and ContainingMessage refer to the same message.
-	// Otherwise, ContainingMessage and Parent likely differ.
-	IsExtension() bool
-
-	// HasOptionalKeyword reports whether the "optional" keyword was explicitly
-	// specified in the source .proto file.
-	HasOptionalKeyword() bool
-
-	// IsWeak reports whether this is a weak field, which does not impose a
-	// direct dependency on the target type.
-	// If true, then Message returns a placeholder type.
-	IsWeak() bool
-
-	// IsPacked reports whether repeated primitive numeric kinds should be
-	// serialized using a packed encoding.
-	// If true, then it implies Cardinality is Repeated.
-	IsPacked() bool
-
-	// IsList reports whether this field represents a list,
-	// where the value type for the associated field is a List.
-	// It is equivalent to checking whether Cardinality is Repeated and
-	// that IsMap reports false.
-	IsList() bool
-
-	// IsMap reports whether this field represents a map,
-	// where the value type for the associated field is a Map.
-	// It is equivalent to checking whether Cardinality is Repeated,
-	// that the Kind is MessageKind, and that Message.IsMapEntry reports true.
-	IsMap() bool
-
-	// MapKey returns the field descriptor for the key in the map entry.
-	// It returns nil if IsMap reports false.
-	MapKey() FieldDescriptor
-
-	// MapValue returns the field descriptor for the value in the map entry.
-	// It returns nil if IsMap reports false.
-	MapValue() FieldDescriptor
-
-	// HasDefault reports whether this field has a default value.
-	HasDefault() bool
-
-	// Default returns the default value for scalar fields.
-	// For proto2, it is the default value as specified in the proto file,
-	// or the zero value if unspecified.
-	// For proto3, it is always the zero value of the scalar.
-	// The Value type is determined by the Kind.
-	Default() Value
-
-	// DefaultEnumValue returns the enum value descriptor for the default value
-	// of an enum field, and is nil for any other kind of field.
-	DefaultEnumValue() EnumValueDescriptor
-
-	// ContainingOneof is the containing oneof that this field belongs to,
-	// and is nil if this field is not part of a oneof.
-	ContainingOneof() OneofDescriptor
-
-	// ContainingMessage is the containing message that this field belongs to.
-	// For extension fields, this may not necessarily be the parent message
-	// that the field is declared within.
-	ContainingMessage() MessageDescriptor
-
-	// Enum is the enum descriptor if Kind is EnumKind.
-	// It returns nil for any other Kind.
-	Enum() EnumDescriptor
-
-	// Message is the message descriptor if Kind is
-	// MessageKind or GroupKind. It returns nil for any other Kind.
-	Message() MessageDescriptor
-
-	isFieldDescriptor
-}
-type isFieldDescriptor interface{ ProtoType(FieldDescriptor) }
-
-// FieldDescriptors is a list of field declarations.
-type FieldDescriptors interface {
-	// Len reports the number of fields.
-	Len() int
-	// Get returns the ith FieldDescriptor. It panics if out of bounds.
-	Get(i int) FieldDescriptor
-	// ByName returns the FieldDescriptor for a field named s.
-	// It returns nil if not found.
-	ByName(s Name) FieldDescriptor
-	// ByJSONName returns the FieldDescriptor for a field with s as the JSON name.
-	// It returns nil if not found.
-	ByJSONName(s string) FieldDescriptor
-	// ByNumber returns the FieldDescriptor for a field numbered n.
-	// It returns nil if not found.
-	ByNumber(n FieldNumber) FieldDescriptor
-
-	doNotImplement
-}
-
-// OneofDescriptor describes a oneof field set within a given message and
-// corresponds with the google.protobuf.OneofDescriptorProto message.
-type OneofDescriptor interface {
-	Descriptor
-
-	// IsSynthetic reports whether this is a synthetic oneof created to support
-	// proto3 optional semantics. If true, Fields contains exactly one field
-	// with HasOptionalKeyword specified.
-	IsSynthetic() bool
-
-	// Fields is a list of fields belonging to this oneof.
-	Fields() FieldDescriptors
-
-	isOneofDescriptor
-}
-type isOneofDescriptor interface{ ProtoType(OneofDescriptor) }
-
-// OneofDescriptors is a list of oneof declarations.
-type OneofDescriptors interface {
-	// Len reports the number of oneof fields.
-	Len() int
-	// Get returns the ith OneofDescriptor. It panics if out of bounds.
-	Get(i int) OneofDescriptor
-	// ByName returns the OneofDescriptor for a oneof named s.
-	// It returns nil if not found.
-	ByName(s Name) OneofDescriptor
-
-	doNotImplement
-}
-
-// ExtensionDescriptor is an alias of FieldDescriptor for documentation.
-type ExtensionDescriptor = FieldDescriptor
-
-// ExtensionTypeDescriptor is an ExtensionDescriptor with an associated ExtensionType.
-type ExtensionTypeDescriptor interface {
-	ExtensionDescriptor
-
-	// Type returns the associated ExtensionType.
-	Type() ExtensionType
-
-	// Descriptor returns the plain ExtensionDescriptor without the
-	// associated ExtensionType.
-	Descriptor() ExtensionDescriptor
-}
-
-// ExtensionDescriptors is a list of field declarations.
-type ExtensionDescriptors interface {
-	// Len reports the number of fields.
-	Len() int
-	// Get returns the ith ExtensionDescriptor. It panics if out of bounds.
-	Get(i int) ExtensionDescriptor
-	// ByName returns the ExtensionDescriptor for a field named s.
-	// It returns nil if not found.
-	ByName(s Name) ExtensionDescriptor
-
-	doNotImplement
-}
-
-// ExtensionType encapsulates an ExtensionDescriptor with a concrete
-// Go implementation. The nested field descriptor must be for a extension field.
-//
-// While a normal field is a member of the parent message that it is declared
-// within (see Descriptor.Parent), an extension field is a member of some other
-// target message (see ExtensionDescriptor.Extendee) and may have no
-// relationship with the parent. However, the full name of an extension field is
-// relative to the parent that it is declared within.
-//
-// For example:
-//	syntax = "proto2";
-//	package example;
-//	message FooMessage {
-//		extensions 100 to max;
-//	}
-//	message BarMessage {
-//		extends FooMessage { optional BarMessage bar_field = 100; }
-//	}
-//
-// Field "bar_field" is an extension of FooMessage, but its full name is
-// "example.BarMessage.bar_field" instead of "example.FooMessage.bar_field".
-type ExtensionType interface {
-	// New returns a new value for the field.
-	// For scalars, this returns the default value in native Go form.
-	New() Value
-
-	// Zero returns a new value for the field.
-	// For scalars, this returns the default value in native Go form.
-	// For composite types, this returns an empty, read-only message, list, or map.
-	Zero() Value
-
-	// TypeDescriptor returns the extension type descriptor.
-	TypeDescriptor() ExtensionTypeDescriptor
-
-	// ValueOf wraps the input and returns it as a Value.
-	// ValueOf panics if the input value is invalid or not the appropriate type.
-	//
-	// ValueOf is more extensive than protoreflect.ValueOf for a given field's
-	// value as it has more type information available.
-	ValueOf(interface{}) Value
-
-	// InterfaceOf completely unwraps the Value to the underlying Go type.
-	// InterfaceOf panics if the input is nil or does not represent the
-	// appropriate underlying Go type. For composite types, it panics if the
-	// value is not mutable.
-	//
-	// InterfaceOf is able to unwrap the Value further than Value.Interface
-	// as it has more type information available.
-	InterfaceOf(Value) interface{}
-
-	// IsValidValue reports whether the Value is valid to assign to the field.
-	IsValidValue(Value) bool
-
-	// IsValidInterface reports whether the input is valid to assign to the field.
-	IsValidInterface(interface{}) bool
-}
-
-// EnumDescriptor describes an enum and
-// corresponds with the google.protobuf.EnumDescriptorProto message.
-//
-// Nested declarations:
-// EnumValueDescriptor.
-type EnumDescriptor interface {
-	Descriptor
-
-	// Values is a list of nested enum value declarations.
-	Values() EnumValueDescriptors
-
-	// ReservedNames is a list of reserved enum names.
-	ReservedNames() Names
-	// ReservedRanges is a list of reserved ranges of enum numbers.
-	ReservedRanges() EnumRanges
-
-	isEnumDescriptor
-}
-type isEnumDescriptor interface{ ProtoType(EnumDescriptor) }
-
-// EnumType encapsulates an EnumDescriptor with a concrete Go implementation.
-type EnumType interface {
-	// New returns an instance of this enum type with its value set to n.
-	New(n EnumNumber) Enum
-
-	// Descriptor returns the enum descriptor.
-	//
-	// Invariant: t.Descriptor() == t.New(0).Descriptor()
-	Descriptor() EnumDescriptor
-}
-
-// EnumDescriptors is a list of enum declarations.
-type EnumDescriptors interface {
-	// Len reports the number of enum types.
-	Len() int
-	// Get returns the ith EnumDescriptor. It panics if out of bounds.
-	Get(i int) EnumDescriptor
-	// ByName returns the EnumDescriptor for an enum named s.
-	// It returns nil if not found.
-	ByName(s Name) EnumDescriptor
-
-	doNotImplement
-}
-
-// EnumValueDescriptor describes an enum value and
-// corresponds with the google.protobuf.EnumValueDescriptorProto message.
-//
-// All other proto declarations are in the namespace of the parent.
-// However, enum values do not follow this rule and are within the namespace
-// of the parent's parent (i.e., they are a sibling of the containing enum).
-// Thus, a value named "FOO_VALUE" declared within an enum uniquely identified
-// as "proto.package.MyEnum" has a full name of "proto.package.FOO_VALUE".
-type EnumValueDescriptor interface {
-	Descriptor
-
-	// Number returns the enum value as an integer.
-	Number() EnumNumber
-
-	isEnumValueDescriptor
-}
-type isEnumValueDescriptor interface{ ProtoType(EnumValueDescriptor) }
-
-// EnumValueDescriptors is a list of enum value declarations.
-type EnumValueDescriptors interface {
-	// Len reports the number of enum values.
-	Len() int
-	// Get returns the ith EnumValueDescriptor. It panics if out of bounds.
-	Get(i int) EnumValueDescriptor
-	// ByName returns the EnumValueDescriptor for the enum value named s.
-	// It returns nil if not found.
-	ByName(s Name) EnumValueDescriptor
-	// ByNumber returns the EnumValueDescriptor for the enum value numbered n.
-	// If multiple have the same number, the first one defined is returned
-	// It returns nil if not found.
-	ByNumber(n EnumNumber) EnumValueDescriptor
-
-	doNotImplement
-}
-
-// ServiceDescriptor describes a service and
-// corresponds with the google.protobuf.ServiceDescriptorProto message.
-//
-// Nested declarations: MethodDescriptor.
-type ServiceDescriptor interface {
-	Descriptor
-
-	// Methods is a list of nested message declarations.
-	Methods() MethodDescriptors
-
-	isServiceDescriptor
-}
-type isServiceDescriptor interface{ ProtoType(ServiceDescriptor) }
-
-// ServiceDescriptors is a list of service declarations.
-type ServiceDescriptors interface {
-	// Len reports the number of services.
-	Len() int
-	// Get returns the ith ServiceDescriptor. It panics if out of bounds.
-	Get(i int) ServiceDescriptor
-	// ByName returns the ServiceDescriptor for a service named s.
-	// It returns nil if not found.
-	ByName(s Name) ServiceDescriptor
-
-	doNotImplement
-}
-
-// MethodDescriptor describes a method and
-// corresponds with the google.protobuf.MethodDescriptorProto message.
-type MethodDescriptor interface {
-	Descriptor
-
-	// Input is the input message descriptor.
-	Input() MessageDescriptor
-	// Output is the output message descriptor.
-	Output() MessageDescriptor
-	// IsStreamingClient reports whether the client streams multiple messages.
-	IsStreamingClient() bool
-	// IsStreamingServer reports whether the server streams multiple messages.
-	IsStreamingServer() bool
-
-	isMethodDescriptor
-}
-type isMethodDescriptor interface{ ProtoType(MethodDescriptor) }
-
-// MethodDescriptors is a list of method declarations.
-type MethodDescriptors interface {
-	// Len reports the number of methods.
-	Len() int
-	// Get returns the ith MethodDescriptor. It panics if out of bounds.
-	Get(i int) MethodDescriptor
-	// ByName returns the MethodDescriptor for a service method named s.
-	// It returns nil if not found.
-	ByName(s Name) MethodDescriptor
-
-	doNotImplement
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value.go
deleted file mode 100644
index f319810..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value.go
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoreflect
-
-import "google.golang.org/protobuf/encoding/protowire"
-
-// Enum is a reflection interface for a concrete enum value,
-// which provides type information and a getter for the enum number.
-// Enum does not provide a mutable API since enums are commonly backed by
-// Go constants, which are not addressable.
-type Enum interface {
-	// Descriptor returns enum descriptor, which contains only the protobuf
-	// type information for the enum.
-	Descriptor() EnumDescriptor
-
-	// Type returns the enum type, which encapsulates both Go and protobuf
-	// type information. If the Go type information is not needed,
-	// it is recommended that the enum descriptor be used instead.
-	Type() EnumType
-
-	// Number returns the enum value as an integer.
-	Number() EnumNumber
-}
-
-// Message is a reflective interface for a concrete message value,
-// encapsulating both type and value information for the message.
-//
-// Accessor/mutators for individual fields are keyed by FieldDescriptor.
-// For non-extension fields, the descriptor must exactly match the
-// field known by the parent message.
-// For extension fields, the descriptor must implement ExtensionTypeDescriptor,
-// extend the parent message (i.e., have the same message FullName), and
-// be within the parent's extension range.
-//
-// Each field Value can be a scalar or a composite type (Message, List, or Map).
-// See Value for the Go types associated with a FieldDescriptor.
-// Providing a Value that is invalid or of an incorrect type panics.
-type Message interface {
-	// Descriptor returns message descriptor, which contains only the protobuf
-	// type information for the message.
-	Descriptor() MessageDescriptor
-
-	// Type returns the message type, which encapsulates both Go and protobuf
-	// type information. If the Go type information is not needed,
-	// it is recommended that the message descriptor be used instead.
-	Type() MessageType
-
-	// New returns a newly allocated and mutable empty message.
-	New() Message
-
-	// Interface unwraps the message reflection interface and
-	// returns the underlying ProtoMessage interface.
-	Interface() ProtoMessage
-
-	// Range iterates over every populated field in an undefined order,
-	// calling f for each field descriptor and value encountered.
-	// Range returns immediately if f returns false.
-	// While iterating, mutating operations may only be performed
-	// on the current field descriptor.
-	Range(f func(FieldDescriptor, Value) bool)
-
-	// Has reports whether a field is populated.
-	//
-	// Some fields have the property of nullability where it is possible to
-	// distinguish between the default value of a field and whether the field
-	// was explicitly populated with the default value. Singular message fields,
-	// member fields of a oneof, and proto2 scalar fields are nullable. Such
-	// fields are populated only if explicitly set.
-	//
-	// In other cases (aside from the nullable cases above),
-	// a proto3 scalar field is populated if it contains a non-zero value, and
-	// a repeated field is populated if it is non-empty.
-	Has(FieldDescriptor) bool
-
-	// Clear clears the field such that a subsequent Has call reports false.
-	//
-	// Clearing an extension field clears both the extension type and value
-	// associated with the given field number.
-	//
-	// Clear is a mutating operation and unsafe for concurrent use.
-	Clear(FieldDescriptor)
-
-	// Get retrieves the value for a field.
-	//
-	// For unpopulated scalars, it returns the default value, where
-	// the default value of a bytes scalar is guaranteed to be a copy.
-	// For unpopulated composite types, it returns an empty, read-only view
-	// of the value; to obtain a mutable reference, use Mutable.
-	Get(FieldDescriptor) Value
-
-	// Set stores the value for a field.
-	//
-	// For a field belonging to a oneof, it implicitly clears any other field
-	// that may be currently set within the same oneof.
-	// For extension fields, it implicitly stores the provided ExtensionType.
-	// When setting a composite type, it is unspecified whether the stored value
-	// aliases the source's memory in any way. If the composite value is an
-	// empty, read-only value, then it panics.
-	//
-	// Set is a mutating operation and unsafe for concurrent use.
-	Set(FieldDescriptor, Value)
-
-	// Mutable returns a mutable reference to a composite type.
-	//
-	// If the field is unpopulated, it may allocate a composite value.
-	// For a field belonging to a oneof, it implicitly clears any other field
-	// that may be currently set within the same oneof.
-	// For extension fields, it implicitly stores the provided ExtensionType
-	// if not already stored.
-	// It panics if the field does not contain a composite type.
-	//
-	// Mutable is a mutating operation and unsafe for concurrent use.
-	Mutable(FieldDescriptor) Value
-
-	// NewField returns a new value that is assignable to the field
-	// for the given descriptor. For scalars, this returns the default value.
-	// For lists, maps, and messages, this returns a new, empty, mutable value.
-	NewField(FieldDescriptor) Value
-
-	// WhichOneof reports which field within the oneof is populated,
-	// returning nil if none are populated.
-	// It panics if the oneof descriptor does not belong to this message.
-	WhichOneof(OneofDescriptor) FieldDescriptor
-
-	// GetUnknown retrieves the entire list of unknown fields.
-	// The caller may only mutate the contents of the RawFields
-	// if the mutated bytes are stored back into the message with SetUnknown.
-	GetUnknown() RawFields
-
-	// SetUnknown stores an entire list of unknown fields.
-	// The raw fields must be syntactically valid according to the wire format.
-	// An implementation may panic if this is not the case.
-	// Once stored, the caller must not mutate the content of the RawFields.
-	// An empty RawFields may be passed to clear the fields.
-	//
-	// SetUnknown is a mutating operation and unsafe for concurrent use.
-	SetUnknown(RawFields)
-
-	// IsValid reports whether the message is valid.
-	//
-	// An invalid message is an empty, read-only value.
-	//
-	// An invalid message often corresponds to a nil pointer of the concrete
-	// message type, but the details are implementation dependent.
-	// Validity is not part of the protobuf data model, and may not
-	// be preserved in marshaling or other operations.
-	IsValid() bool
-
-	// ProtoMethods returns optional fast-path implementions of various operations.
-	// This method may return nil.
-	//
-	// The returned methods type is identical to
-	// "google.golang.org/protobuf/runtime/protoiface".Methods.
-	// Consult the protoiface package documentation for details.
-	ProtoMethods() *methods
-}
-
-// RawFields is the raw bytes for an ordered sequence of fields.
-// Each field contains both the tag (representing field number and wire type),
-// and also the wire data itself.
-type RawFields []byte
-
-// IsValid reports whether b is syntactically correct wire format.
-func (b RawFields) IsValid() bool {
-	for len(b) > 0 {
-		_, _, n := protowire.ConsumeField(b)
-		if n < 0 {
-			return false
-		}
-		b = b[n:]
-	}
-	return true
-}
-
-// List is a zero-indexed, ordered list.
-// The element Value type is determined by FieldDescriptor.Kind.
-// Providing a Value that is invalid or of an incorrect type panics.
-type List interface {
-	// Len reports the number of entries in the List.
-	// Get, Set, and Truncate panic with out of bound indexes.
-	Len() int
-
-	// Get retrieves the value at the given index.
-	// It never returns an invalid value.
-	Get(int) Value
-
-	// Set stores a value for the given index.
-	// When setting a composite type, it is unspecified whether the set
-	// value aliases the source's memory in any way.
-	//
-	// Set is a mutating operation and unsafe for concurrent use.
-	Set(int, Value)
-
-	// Append appends the provided value to the end of the list.
-	// When appending a composite type, it is unspecified whether the appended
-	// value aliases the source's memory in any way.
-	//
-	// Append is a mutating operation and unsafe for concurrent use.
-	Append(Value)
-
-	// AppendMutable appends a new, empty, mutable message value to the end
-	// of the list and returns it.
-	// It panics if the list does not contain a message type.
-	AppendMutable() Value
-
-	// Truncate truncates the list to a smaller length.
-	//
-	// Truncate is a mutating operation and unsafe for concurrent use.
-	Truncate(int)
-
-	// NewElement returns a new value for a list element.
-	// For enums, this returns the first enum value.
-	// For other scalars, this returns the zero value.
-	// For messages, this returns a new, empty, mutable value.
-	NewElement() Value
-
-	// IsValid reports whether the list is valid.
-	//
-	// An invalid list is an empty, read-only value.
-	//
-	// Validity is not part of the protobuf data model, and may not
-	// be preserved in marshaling or other operations.
-	IsValid() bool
-}
-
-// Map is an unordered, associative map.
-// The entry MapKey type is determined by FieldDescriptor.MapKey.Kind.
-// The entry Value type is determined by FieldDescriptor.MapValue.Kind.
-// Providing a MapKey or Value that is invalid or of an incorrect type panics.
-type Map interface {
-	// Len reports the number of elements in the map.
-	Len() int
-
-	// Range iterates over every map entry in an undefined order,
-	// calling f for each key and value encountered.
-	// Range calls f Len times unless f returns false, which stops iteration.
-	// While iterating, mutating operations may only be performed
-	// on the current map key.
-	Range(f func(MapKey, Value) bool)
-
-	// Has reports whether an entry with the given key is in the map.
-	Has(MapKey) bool
-
-	// Clear clears the entry associated with they given key.
-	// The operation does nothing if there is no entry associated with the key.
-	//
-	// Clear is a mutating operation and unsafe for concurrent use.
-	Clear(MapKey)
-
-	// Get retrieves the value for an entry with the given key.
-	// It returns an invalid value for non-existent entries.
-	Get(MapKey) Value
-
-	// Set stores the value for an entry with the given key.
-	// It panics when given a key or value that is invalid or the wrong type.
-	// When setting a composite type, it is unspecified whether the set
-	// value aliases the source's memory in any way.
-	//
-	// Set is a mutating operation and unsafe for concurrent use.
-	Set(MapKey, Value)
-
-	// Mutable retrieves a mutable reference to the entry for the given key.
-	// If no entry exists for the key, it creates a new, empty, mutable value
-	// and stores it as the entry for the key.
-	// It panics if the map value is not a message.
-	Mutable(MapKey) Value
-
-	// NewValue returns a new value assignable as a map value.
-	// For enums, this returns the first enum value.
-	// For other scalars, this returns the zero value.
-	// For messages, this returns a new, empty, mutable value.
-	NewValue() Value
-
-	// IsValid reports whether the map is valid.
-	//
-	// An invalid map is an empty, read-only value.
-	//
-	// An invalid message often corresponds to a nil Go map value,
-	// but the details are implementation dependent.
-	// Validity is not part of the protobuf data model, and may not
-	// be preserved in marshaling or other operations.
-	IsValid() bool
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go
deleted file mode 100644
index 918e685..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build purego appengine
-
-package protoreflect
-
-import "google.golang.org/protobuf/internal/pragma"
-
-type valueType int
-
-const (
-	nilType valueType = iota
-	boolType
-	int32Type
-	int64Type
-	uint32Type
-	uint64Type
-	float32Type
-	float64Type
-	stringType
-	bytesType
-	enumType
-	ifaceType
-)
-
-// value is a union where only one type can be represented at a time.
-// This uses a distinct field for each type. This is type safe in Go, but
-// occupies more memory than necessary (72B).
-type value struct {
-	pragma.DoNotCompare // 0B
-
-	typ   valueType   // 8B
-	num   uint64      // 8B
-	str   string      // 16B
-	bin   []byte      // 24B
-	iface interface{} // 16B
-}
-
-func valueOfString(v string) Value {
-	return Value{typ: stringType, str: v}
-}
-func valueOfBytes(v []byte) Value {
-	return Value{typ: bytesType, bin: v}
-}
-func valueOfIface(v interface{}) Value {
-	return Value{typ: ifaceType, iface: v}
-}
-
-func (v Value) getString() string {
-	return v.str
-}
-func (v Value) getBytes() []byte {
-	return v.bin
-}
-func (v Value) getIface() interface{} {
-	return v.iface
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go
deleted file mode 100644
index f334f71..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go
+++ /dev/null
@@ -1,409 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoreflect
-
-import (
-	"fmt"
-	"math"
-)
-
-// Value is a union where only one Go type may be set at a time.
-// The Value is used to represent all possible values a field may take.
-// The following shows which Go type is used to represent each proto Kind:
-//
-//	╔════════════╤═════════════════════════════════════╗
-//	║ Go type    │ Protobuf kind                       ║
-//	╠════════════╪═════════════════════════════════════╣
-//	║ bool       │ BoolKind                            ║
-//	║ int32      │ Int32Kind, Sint32Kind, Sfixed32Kind ║
-//	║ int64      │ Int64Kind, Sint64Kind, Sfixed64Kind ║
-//	║ uint32     │ Uint32Kind, Fixed32Kind             ║
-//	║ uint64     │ Uint64Kind, Fixed64Kind             ║
-//	║ float32    │ FloatKind                           ║
-//	║ float64    │ DoubleKind                          ║
-//	║ string     │ StringKind                          ║
-//	║ []byte     │ BytesKind                           ║
-//	║ EnumNumber │ EnumKind                            ║
-//	║ Message    │ MessageKind, GroupKind              ║
-//	╚════════════╧═════════════════════════════════════╝
-//
-// Multiple protobuf Kinds may be represented by a single Go type if the type
-// can losslessly represent the information for the proto kind. For example,
-// Int64Kind, Sint64Kind, and Sfixed64Kind are all represented by int64,
-// but use different integer encoding methods.
-//
-// The List or Map types are used if the field cardinality is repeated.
-// A field is a List if FieldDescriptor.IsList reports true.
-// A field is a Map if FieldDescriptor.IsMap reports true.
-//
-// Converting to/from a Value and a concrete Go value panics on type mismatch.
-// For example, ValueOf("hello").Int() panics because this attempts to
-// retrieve an int64 from a string.
-type Value value
-
-// The protoreflect API uses a custom Value union type instead of interface{}
-// to keep the future open for performance optimizations. Using an interface{}
-// always incurs an allocation for primitives (e.g., int64) since it needs to
-// be boxed on the heap (as interfaces can only contain pointers natively).
-// Instead, we represent the Value union as a flat struct that internally keeps
-// track of which type is set. Using unsafe, the Value union can be reduced
-// down to 24B, which is identical in size to a slice.
-//
-// The latest compiler (Go1.11) currently suffers from some limitations:
-//	• With inlining, the compiler should be able to statically prove that
-//	only one of these switch cases are taken and inline one specific case.
-//	See https://golang.org/issue/22310.
-
-// ValueOf returns a Value initialized with the concrete value stored in v.
-// This panics if the type does not match one of the allowed types in the
-// Value union.
-func ValueOf(v interface{}) Value {
-	switch v := v.(type) {
-	case nil:
-		return Value{}
-	case bool:
-		return ValueOfBool(v)
-	case int32:
-		return ValueOfInt32(v)
-	case int64:
-		return ValueOfInt64(v)
-	case uint32:
-		return ValueOfUint32(v)
-	case uint64:
-		return ValueOfUint64(v)
-	case float32:
-		return ValueOfFloat32(v)
-	case float64:
-		return ValueOfFloat64(v)
-	case string:
-		return ValueOfString(v)
-	case []byte:
-		return ValueOfBytes(v)
-	case EnumNumber:
-		return ValueOfEnum(v)
-	case Message, List, Map:
-		return valueOfIface(v)
-	default:
-		panic(fmt.Sprintf("invalid type: %T", v))
-	}
-}
-
-// ValueOfBool returns a new boolean value.
-func ValueOfBool(v bool) Value {
-	if v {
-		return Value{typ: boolType, num: 1}
-	} else {
-		return Value{typ: boolType, num: 0}
-	}
-}
-
-// ValueOfInt32 returns a new int32 value.
-func ValueOfInt32(v int32) Value {
-	return Value{typ: int32Type, num: uint64(v)}
-}
-
-// ValueOfInt64 returns a new int64 value.
-func ValueOfInt64(v int64) Value {
-	return Value{typ: int64Type, num: uint64(v)}
-}
-
-// ValueOfUint32 returns a new uint32 value.
-func ValueOfUint32(v uint32) Value {
-	return Value{typ: uint32Type, num: uint64(v)}
-}
-
-// ValueOfUint64 returns a new uint64 value.
-func ValueOfUint64(v uint64) Value {
-	return Value{typ: uint64Type, num: v}
-}
-
-// ValueOfFloat32 returns a new float32 value.
-func ValueOfFloat32(v float32) Value {
-	return Value{typ: float32Type, num: uint64(math.Float64bits(float64(v)))}
-}
-
-// ValueOfFloat64 returns a new float64 value.
-func ValueOfFloat64(v float64) Value {
-	return Value{typ: float64Type, num: uint64(math.Float64bits(float64(v)))}
-}
-
-// ValueOfString returns a new string value.
-func ValueOfString(v string) Value {
-	return valueOfString(v)
-}
-
-// ValueOfBytes returns a new bytes value.
-func ValueOfBytes(v []byte) Value {
-	return valueOfBytes(v[:len(v):len(v)])
-}
-
-// ValueOfEnum returns a new enum value.
-func ValueOfEnum(v EnumNumber) Value {
-	return Value{typ: enumType, num: uint64(v)}
-}
-
-// ValueOfMessage returns a new Message value.
-func ValueOfMessage(v Message) Value {
-	return valueOfIface(v)
-}
-
-// ValueOfList returns a new List value.
-func ValueOfList(v List) Value {
-	return valueOfIface(v)
-}
-
-// ValueOfMap returns a new Map value.
-func ValueOfMap(v Map) Value {
-	return valueOfIface(v)
-}
-
-// IsValid reports whether v is populated with a value.
-func (v Value) IsValid() bool {
-	return v.typ != nilType
-}
-
-// Interface returns v as an interface{}.
-//
-// Invariant: v == ValueOf(v).Interface()
-func (v Value) Interface() interface{} {
-	switch v.typ {
-	case nilType:
-		return nil
-	case boolType:
-		return v.Bool()
-	case int32Type:
-		return int32(v.Int())
-	case int64Type:
-		return int64(v.Int())
-	case uint32Type:
-		return uint32(v.Uint())
-	case uint64Type:
-		return uint64(v.Uint())
-	case float32Type:
-		return float32(v.Float())
-	case float64Type:
-		return float64(v.Float())
-	case stringType:
-		return v.String()
-	case bytesType:
-		return v.Bytes()
-	case enumType:
-		return v.Enum()
-	default:
-		return v.getIface()
-	}
-}
-
-func (v Value) typeName() string {
-	switch v.typ {
-	case nilType:
-		return "nil"
-	case boolType:
-		return "bool"
-	case int32Type:
-		return "int32"
-	case int64Type:
-		return "int64"
-	case uint32Type:
-		return "uint32"
-	case uint64Type:
-		return "uint64"
-	case float32Type:
-		return "float32"
-	case float64Type:
-		return "float64"
-	case stringType:
-		return "string"
-	case bytesType:
-		return "bytes"
-	case enumType:
-		return "enum"
-	default:
-		switch v := v.getIface().(type) {
-		case Message:
-			return "message"
-		case List:
-			return "list"
-		case Map:
-			return "map"
-		default:
-			return fmt.Sprintf("<unknown: %T>", v)
-		}
-	}
-}
-
-func (v Value) panicMessage(what string) string {
-	return fmt.Sprintf("type mismatch: cannot convert %v to %s", v.typeName(), what)
-}
-
-// Bool returns v as a bool and panics if the type is not a bool.
-func (v Value) Bool() bool {
-	switch v.typ {
-	case boolType:
-		return v.num > 0
-	default:
-		panic(v.panicMessage("bool"))
-	}
-}
-
-// Int returns v as a int64 and panics if the type is not a int32 or int64.
-func (v Value) Int() int64 {
-	switch v.typ {
-	case int32Type, int64Type:
-		return int64(v.num)
-	default:
-		panic(v.panicMessage("int"))
-	}
-}
-
-// Uint returns v as a uint64 and panics if the type is not a uint32 or uint64.
-func (v Value) Uint() uint64 {
-	switch v.typ {
-	case uint32Type, uint64Type:
-		return uint64(v.num)
-	default:
-		panic(v.panicMessage("uint"))
-	}
-}
-
-// Float returns v as a float64 and panics if the type is not a float32 or float64.
-func (v Value) Float() float64 {
-	switch v.typ {
-	case float32Type, float64Type:
-		return math.Float64frombits(uint64(v.num))
-	default:
-		panic(v.panicMessage("float"))
-	}
-}
-
-// String returns v as a string. Since this method implements fmt.Stringer,
-// this returns the formatted string value for any non-string type.
-func (v Value) String() string {
-	switch v.typ {
-	case stringType:
-		return v.getString()
-	default:
-		return fmt.Sprint(v.Interface())
-	}
-}
-
-// Bytes returns v as a []byte and panics if the type is not a []byte.
-func (v Value) Bytes() []byte {
-	switch v.typ {
-	case bytesType:
-		return v.getBytes()
-	default:
-		panic(v.panicMessage("bytes"))
-	}
-}
-
-// Enum returns v as a EnumNumber and panics if the type is not a EnumNumber.
-func (v Value) Enum() EnumNumber {
-	switch v.typ {
-	case enumType:
-		return EnumNumber(v.num)
-	default:
-		panic(v.panicMessage("enum"))
-	}
-}
-
-// Message returns v as a Message and panics if the type is not a Message.
-func (v Value) Message() Message {
-	switch vi := v.getIface().(type) {
-	case Message:
-		return vi
-	default:
-		panic(v.panicMessage("message"))
-	}
-}
-
-// List returns v as a List and panics if the type is not a List.
-func (v Value) List() List {
-	switch vi := v.getIface().(type) {
-	case List:
-		return vi
-	default:
-		panic(v.panicMessage("list"))
-	}
-}
-
-// Map returns v as a Map and panics if the type is not a Map.
-func (v Value) Map() Map {
-	switch vi := v.getIface().(type) {
-	case Map:
-		return vi
-	default:
-		panic(v.panicMessage("map"))
-	}
-}
-
-// MapKey returns v as a MapKey and panics for invalid MapKey types.
-func (v Value) MapKey() MapKey {
-	switch v.typ {
-	case boolType, int32Type, int64Type, uint32Type, uint64Type, stringType:
-		return MapKey(v)
-	default:
-		panic(v.panicMessage("map key"))
-	}
-}
-
-// MapKey is used to index maps, where the Go type of the MapKey must match
-// the specified key Kind (see MessageDescriptor.IsMapEntry).
-// The following shows what Go type is used to represent each proto Kind:
-//
-//	╔═════════╤═════════════════════════════════════╗
-//	║ Go type │ Protobuf kind                       ║
-//	╠═════════╪═════════════════════════════════════╣
-//	║ bool    │ BoolKind                            ║
-//	║ int32   │ Int32Kind, Sint32Kind, Sfixed32Kind ║
-//	║ int64   │ Int64Kind, Sint64Kind, Sfixed64Kind ║
-//	║ uint32  │ Uint32Kind, Fixed32Kind             ║
-//	║ uint64  │ Uint64Kind, Fixed64Kind             ║
-//	║ string  │ StringKind                          ║
-//	╚═════════╧═════════════════════════════════════╝
-//
-// A MapKey is constructed and accessed through a Value:
-//	k := ValueOf("hash").MapKey() // convert string to MapKey
-//	s := k.String()               // convert MapKey to string
-//
-// The MapKey is a strict subset of valid types used in Value;
-// converting a Value to a MapKey with an invalid type panics.
-type MapKey value
-
-// IsValid reports whether k is populated with a value.
-func (k MapKey) IsValid() bool {
-	return Value(k).IsValid()
-}
-
-// Interface returns k as an interface{}.
-func (k MapKey) Interface() interface{} {
-	return Value(k).Interface()
-}
-
-// Bool returns k as a bool and panics if the type is not a bool.
-func (k MapKey) Bool() bool {
-	return Value(k).Bool()
-}
-
-// Int returns k as a int64 and panics if the type is not a int32 or int64.
-func (k MapKey) Int() int64 {
-	return Value(k).Int()
-}
-
-// Uint returns k as a uint64 and panics if the type is not a uint32 or uint64.
-func (k MapKey) Uint() uint64 {
-	return Value(k).Uint()
-}
-
-// String returns k as a string. Since this method implements fmt.Stringer,
-// this returns the formatted string value for any non-string type.
-func (k MapKey) String() string {
-	return Value(k).String()
-}
-
-// Value returns k as a Value.
-func (k MapKey) Value() Value {
-	return Value(k)
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe.go
deleted file mode 100644
index c45debd..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !purego,!appengine
-
-package protoreflect
-
-import (
-	"unsafe"
-
-	"google.golang.org/protobuf/internal/pragma"
-)
-
-type (
-	stringHeader struct {
-		Data unsafe.Pointer
-		Len  int
-	}
-	sliceHeader struct {
-		Data unsafe.Pointer
-		Len  int
-		Cap  int
-	}
-	ifaceHeader struct {
-		Type unsafe.Pointer
-		Data unsafe.Pointer
-	}
-)
-
-var (
-	nilType     = typeOf(nil)
-	boolType    = typeOf(*new(bool))
-	int32Type   = typeOf(*new(int32))
-	int64Type   = typeOf(*new(int64))
-	uint32Type  = typeOf(*new(uint32))
-	uint64Type  = typeOf(*new(uint64))
-	float32Type = typeOf(*new(float32))
-	float64Type = typeOf(*new(float64))
-	stringType  = typeOf(*new(string))
-	bytesType   = typeOf(*new([]byte))
-	enumType    = typeOf(*new(EnumNumber))
-)
-
-// typeOf returns a pointer to the Go type information.
-// The pointer is comparable and equal if and only if the types are identical.
-func typeOf(t interface{}) unsafe.Pointer {
-	return (*ifaceHeader)(unsafe.Pointer(&t)).Type
-}
-
-// value is a union where only one type can be represented at a time.
-// The struct is 24B large on 64-bit systems and requires the minimum storage
-// necessary to represent each possible type.
-//
-// The Go GC needs to be able to scan variables containing pointers.
-// As such, pointers and non-pointers cannot be intermixed.
-type value struct {
-	pragma.DoNotCompare // 0B
-
-	// typ stores the type of the value as a pointer to the Go type.
-	typ unsafe.Pointer // 8B
-
-	// ptr stores the data pointer for a String, Bytes, or interface value.
-	ptr unsafe.Pointer // 8B
-
-	// num stores a Bool, Int32, Int64, Uint32, Uint64, Float32, Float64, or
-	// Enum value as a raw uint64.
-	//
-	// It is also used to store the length of a String or Bytes value;
-	// the capacity is ignored.
-	num uint64 // 8B
-}
-
-func valueOfString(v string) Value {
-	p := (*stringHeader)(unsafe.Pointer(&v))
-	return Value{typ: stringType, ptr: p.Data, num: uint64(len(v))}
-}
-func valueOfBytes(v []byte) Value {
-	p := (*sliceHeader)(unsafe.Pointer(&v))
-	return Value{typ: bytesType, ptr: p.Data, num: uint64(len(v))}
-}
-func valueOfIface(v interface{}) Value {
-	p := (*ifaceHeader)(unsafe.Pointer(&v))
-	return Value{typ: p.Type, ptr: p.Data}
-}
-
-func (v Value) getString() (x string) {
-	*(*stringHeader)(unsafe.Pointer(&x)) = stringHeader{Data: v.ptr, Len: int(v.num)}
-	return x
-}
-func (v Value) getBytes() (x []byte) {
-	*(*sliceHeader)(unsafe.Pointer(&x)) = sliceHeader{Data: v.ptr, Len: int(v.num), Cap: int(v.num)}
-	return x
-}
-func (v Value) getIface() (x interface{}) {
-	*(*ifaceHeader)(unsafe.Pointer(&x)) = ifaceHeader{Type: v.typ, Data: v.ptr}
-	return x
-}
diff --git a/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go b/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go
deleted file mode 100644
index 43f16c6..0000000
--- a/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go
+++ /dev/null
@@ -1,768 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protoregistry provides data structures to register and lookup
-// protobuf descriptor types.
-//
-// The Files registry contains file descriptors and provides the ability
-// to iterate over the files or lookup a specific descriptor within the files.
-// Files only contains protobuf descriptors and has no understanding of Go
-// type information that may be associated with each descriptor.
-//
-// The Types registry contains descriptor types for which there is a known
-// Go type associated with that descriptor. It provides the ability to iterate
-// over the registered types or lookup a type by name.
-package protoregistry
-
-import (
-	"fmt"
-	"log"
-	"strings"
-	"sync"
-
-	"google.golang.org/protobuf/internal/errors"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// ignoreConflict reports whether to ignore a registration conflict
-// given the descriptor being registered and the error.
-// It is a variable so that the behavior is easily overridden in another file.
-var ignoreConflict = func(d protoreflect.Descriptor, err error) bool {
-	log.Printf(""+
-		"WARNING: %v\n"+
-		"A future release will panic on registration conflicts. See:\n"+
-		"https://developers.google.com/protocol-buffers/docs/reference/go/faq#namespace-conflict\n"+
-		"\n", err)
-	return true
-}
-
-var globalMutex sync.RWMutex
-
-// GlobalFiles is a global registry of file descriptors.
-var GlobalFiles *Files = new(Files)
-
-// GlobalTypes is the registry used by default for type lookups
-// unless a local registry is provided by the user.
-var GlobalTypes *Types = new(Types)
-
-// NotFound is a sentinel error value to indicate that the type was not found.
-//
-// Since registry lookup can happen in the critical performance path, resolvers
-// must return this exact error value, not an error wrapping it.
-var NotFound = errors.New("not found")
-
-// Files is a registry for looking up or iterating over files and the
-// descriptors contained within them.
-// The Find and Range methods are safe for concurrent use.
-type Files struct {
-	// The map of descsByName contains:
-	//	EnumDescriptor
-	//	EnumValueDescriptor
-	//	MessageDescriptor
-	//	ExtensionDescriptor
-	//	ServiceDescriptor
-	//	*packageDescriptor
-	//
-	// Note that files are stored as a slice, since a package may contain
-	// multiple files. Only top-level declarations are registered.
-	// Note that enum values are in the top-level since that are in the same
-	// scope as the parent enum.
-	descsByName map[protoreflect.FullName]interface{}
-	filesByPath map[string]protoreflect.FileDescriptor
-}
-
-type packageDescriptor struct {
-	files []protoreflect.FileDescriptor
-}
-
-// RegisterFile registers the provided file descriptor.
-//
-// If any descriptor within the file conflicts with the descriptor of any
-// previously registered file (e.g., two enums with the same full name),
-// then the file is not registered and an error is returned.
-//
-// It is permitted for multiple files to have the same file path.
-func (r *Files) RegisterFile(file protoreflect.FileDescriptor) error {
-	if r == GlobalFiles {
-		globalMutex.Lock()
-		defer globalMutex.Unlock()
-	}
-	if r.descsByName == nil {
-		r.descsByName = map[protoreflect.FullName]interface{}{
-			"": &packageDescriptor{},
-		}
-		r.filesByPath = make(map[string]protoreflect.FileDescriptor)
-	}
-	path := file.Path()
-	if prev := r.filesByPath[path]; prev != nil {
-		err := errors.New("file %q is already registered", file.Path())
-		err = amendErrorWithCaller(err, prev, file)
-		if r == GlobalFiles && ignoreConflict(file, err) {
-			err = nil
-		}
-		return err
-	}
-
-	for name := file.Package(); name != ""; name = name.Parent() {
-		switch prev := r.descsByName[name]; prev.(type) {
-		case nil, *packageDescriptor:
-		default:
-			err := errors.New("file %q has a package name conflict over %v", file.Path(), name)
-			err = amendErrorWithCaller(err, prev, file)
-			if r == GlobalFiles && ignoreConflict(file, err) {
-				err = nil
-			}
-			return err
-		}
-	}
-	var err error
-	var hasConflict bool
-	rangeTopLevelDescriptors(file, func(d protoreflect.Descriptor) {
-		if prev := r.descsByName[d.FullName()]; prev != nil {
-			hasConflict = true
-			err = errors.New("file %q has a name conflict over %v", file.Path(), d.FullName())
-			err = amendErrorWithCaller(err, prev, file)
-			if r == GlobalFiles && ignoreConflict(d, err) {
-				err = nil
-			}
-		}
-	})
-	if hasConflict {
-		return err
-	}
-
-	for name := file.Package(); name != ""; name = name.Parent() {
-		if r.descsByName[name] == nil {
-			r.descsByName[name] = &packageDescriptor{}
-		}
-	}
-	p := r.descsByName[file.Package()].(*packageDescriptor)
-	p.files = append(p.files, file)
-	rangeTopLevelDescriptors(file, func(d protoreflect.Descriptor) {
-		r.descsByName[d.FullName()] = d
-	})
-	r.filesByPath[path] = file
-	return nil
-}
-
-// FindDescriptorByName looks up a descriptor by the full name.
-//
-// This returns (nil, NotFound) if not found.
-func (r *Files) FindDescriptorByName(name protoreflect.FullName) (protoreflect.Descriptor, error) {
-	if r == nil {
-		return nil, NotFound
-	}
-	if r == GlobalFiles {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	prefix := name
-	suffix := nameSuffix("")
-	for prefix != "" {
-		if d, ok := r.descsByName[prefix]; ok {
-			switch d := d.(type) {
-			case protoreflect.EnumDescriptor:
-				if d.FullName() == name {
-					return d, nil
-				}
-			case protoreflect.EnumValueDescriptor:
-				if d.FullName() == name {
-					return d, nil
-				}
-			case protoreflect.MessageDescriptor:
-				if d.FullName() == name {
-					return d, nil
-				}
-				if d := findDescriptorInMessage(d, suffix); d != nil && d.FullName() == name {
-					return d, nil
-				}
-			case protoreflect.ExtensionDescriptor:
-				if d.FullName() == name {
-					return d, nil
-				}
-			case protoreflect.ServiceDescriptor:
-				if d.FullName() == name {
-					return d, nil
-				}
-				if d := d.Methods().ByName(suffix.Pop()); d != nil && d.FullName() == name {
-					return d, nil
-				}
-			}
-			return nil, NotFound
-		}
-		prefix = prefix.Parent()
-		suffix = nameSuffix(name[len(prefix)+len("."):])
-	}
-	return nil, NotFound
-}
-
-func findDescriptorInMessage(md protoreflect.MessageDescriptor, suffix nameSuffix) protoreflect.Descriptor {
-	name := suffix.Pop()
-	if suffix == "" {
-		if ed := md.Enums().ByName(name); ed != nil {
-			return ed
-		}
-		for i := md.Enums().Len() - 1; i >= 0; i-- {
-			if vd := md.Enums().Get(i).Values().ByName(name); vd != nil {
-				return vd
-			}
-		}
-		if xd := md.Extensions().ByName(name); xd != nil {
-			return xd
-		}
-		if fd := md.Fields().ByName(name); fd != nil {
-			return fd
-		}
-		if od := md.Oneofs().ByName(name); od != nil {
-			return od
-		}
-	}
-	if md := md.Messages().ByName(name); md != nil {
-		if suffix == "" {
-			return md
-		}
-		return findDescriptorInMessage(md, suffix)
-	}
-	return nil
-}
-
-type nameSuffix string
-
-func (s *nameSuffix) Pop() (name protoreflect.Name) {
-	if i := strings.IndexByte(string(*s), '.'); i >= 0 {
-		name, *s = protoreflect.Name((*s)[:i]), (*s)[i+1:]
-	} else {
-		name, *s = protoreflect.Name((*s)), ""
-	}
-	return name
-}
-
-// FindFileByPath looks up a file by the path.
-//
-// This returns (nil, NotFound) if not found.
-func (r *Files) FindFileByPath(path string) (protoreflect.FileDescriptor, error) {
-	if r == nil {
-		return nil, NotFound
-	}
-	if r == GlobalFiles {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	if fd, ok := r.filesByPath[path]; ok {
-		return fd, nil
-	}
-	return nil, NotFound
-}
-
-// NumFiles reports the number of registered files.
-func (r *Files) NumFiles() int {
-	if r == nil {
-		return 0
-	}
-	if r == GlobalFiles {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	return len(r.filesByPath)
-}
-
-// RangeFiles iterates over all registered files while f returns true.
-// The iteration order is undefined.
-func (r *Files) RangeFiles(f func(protoreflect.FileDescriptor) bool) {
-	if r == nil {
-		return
-	}
-	if r == GlobalFiles {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	for _, file := range r.filesByPath {
-		if !f(file) {
-			return
-		}
-	}
-}
-
-// NumFilesByPackage reports the number of registered files in a proto package.
-func (r *Files) NumFilesByPackage(name protoreflect.FullName) int {
-	if r == nil {
-		return 0
-	}
-	if r == GlobalFiles {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	p, ok := r.descsByName[name].(*packageDescriptor)
-	if !ok {
-		return 0
-	}
-	return len(p.files)
-}
-
-// RangeFilesByPackage iterates over all registered files in a given proto package
-// while f returns true. The iteration order is undefined.
-func (r *Files) RangeFilesByPackage(name protoreflect.FullName, f func(protoreflect.FileDescriptor) bool) {
-	if r == nil {
-		return
-	}
-	if r == GlobalFiles {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	p, ok := r.descsByName[name].(*packageDescriptor)
-	if !ok {
-		return
-	}
-	for _, file := range p.files {
-		if !f(file) {
-			return
-		}
-	}
-}
-
-// rangeTopLevelDescriptors iterates over all top-level descriptors in a file
-// which will be directly entered into the registry.
-func rangeTopLevelDescriptors(fd protoreflect.FileDescriptor, f func(protoreflect.Descriptor)) {
-	eds := fd.Enums()
-	for i := eds.Len() - 1; i >= 0; i-- {
-		f(eds.Get(i))
-		vds := eds.Get(i).Values()
-		for i := vds.Len() - 1; i >= 0; i-- {
-			f(vds.Get(i))
-		}
-	}
-	mds := fd.Messages()
-	for i := mds.Len() - 1; i >= 0; i-- {
-		f(mds.Get(i))
-	}
-	xds := fd.Extensions()
-	for i := xds.Len() - 1; i >= 0; i-- {
-		f(xds.Get(i))
-	}
-	sds := fd.Services()
-	for i := sds.Len() - 1; i >= 0; i-- {
-		f(sds.Get(i))
-	}
-}
-
-// MessageTypeResolver is an interface for looking up messages.
-//
-// A compliant implementation must deterministically return the same type
-// if no error is encountered.
-//
-// The Types type implements this interface.
-type MessageTypeResolver interface {
-	// FindMessageByName looks up a message by its full name.
-	// E.g., "google.protobuf.Any"
-	//
-	// This return (nil, NotFound) if not found.
-	FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error)
-
-	// FindMessageByURL looks up a message by a URL identifier.
-	// See documentation on google.protobuf.Any.type_url for the URL format.
-	//
-	// This returns (nil, NotFound) if not found.
-	FindMessageByURL(url string) (protoreflect.MessageType, error)
-}
-
-// ExtensionTypeResolver is an interface for looking up extensions.
-//
-// A compliant implementation must deterministically return the same type
-// if no error is encountered.
-//
-// The Types type implements this interface.
-type ExtensionTypeResolver interface {
-	// FindExtensionByName looks up a extension field by the field's full name.
-	// Note that this is the full name of the field as determined by
-	// where the extension is declared and is unrelated to the full name of the
-	// message being extended.
-	//
-	// This returns (nil, NotFound) if not found.
-	FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
-
-	// FindExtensionByNumber looks up a extension field by the field number
-	// within some parent message, identified by full name.
-	//
-	// This returns (nil, NotFound) if not found.
-	FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
-}
-
-var (
-	_ MessageTypeResolver   = (*Types)(nil)
-	_ ExtensionTypeResolver = (*Types)(nil)
-)
-
-// Types is a registry for looking up or iterating over descriptor types.
-// The Find and Range methods are safe for concurrent use.
-type Types struct {
-	typesByName         typesByName
-	extensionsByMessage extensionsByMessage
-
-	numEnums      int
-	numMessages   int
-	numExtensions int
-}
-
-type (
-	typesByName         map[protoreflect.FullName]interface{}
-	extensionsByMessage map[protoreflect.FullName]extensionsByNumber
-	extensionsByNumber  map[protoreflect.FieldNumber]protoreflect.ExtensionType
-)
-
-// RegisterMessage registers the provided message type.
-//
-// If a naming conflict occurs, the type is not registered and an error is returned.
-func (r *Types) RegisterMessage(mt protoreflect.MessageType) error {
-	// Under rare circumstances getting the descriptor might recursively
-	// examine the registry, so fetch it before locking.
-	md := mt.Descriptor()
-
-	if r == GlobalTypes {
-		globalMutex.Lock()
-		defer globalMutex.Unlock()
-	}
-
-	if err := r.register("message", md, mt); err != nil {
-		return err
-	}
-	r.numMessages++
-	return nil
-}
-
-// RegisterEnum registers the provided enum type.
-//
-// If a naming conflict occurs, the type is not registered and an error is returned.
-func (r *Types) RegisterEnum(et protoreflect.EnumType) error {
-	// Under rare circumstances getting the descriptor might recursively
-	// examine the registry, so fetch it before locking.
-	ed := et.Descriptor()
-
-	if r == GlobalTypes {
-		globalMutex.Lock()
-		defer globalMutex.Unlock()
-	}
-
-	if err := r.register("enum", ed, et); err != nil {
-		return err
-	}
-	r.numEnums++
-	return nil
-}
-
-// RegisterExtension registers the provided extension type.
-//
-// If a naming conflict occurs, the type is not registered and an error is returned.
-func (r *Types) RegisterExtension(xt protoreflect.ExtensionType) error {
-	// Under rare circumstances getting the descriptor might recursively
-	// examine the registry, so fetch it before locking.
-	//
-	// A known case where this can happen: Fetching the TypeDescriptor for a
-	// legacy ExtensionDesc can consult the global registry.
-	xd := xt.TypeDescriptor()
-
-	if r == GlobalTypes {
-		globalMutex.Lock()
-		defer globalMutex.Unlock()
-	}
-
-	field := xd.Number()
-	message := xd.ContainingMessage().FullName()
-	if prev := r.extensionsByMessage[message][field]; prev != nil {
-		err := errors.New("extension number %d is already registered on message %v", field, message)
-		err = amendErrorWithCaller(err, prev, xt)
-		if !(r == GlobalTypes && ignoreConflict(xd, err)) {
-			return err
-		}
-	}
-
-	if err := r.register("extension", xd, xt); err != nil {
-		return err
-	}
-	if r.extensionsByMessage == nil {
-		r.extensionsByMessage = make(extensionsByMessage)
-	}
-	if r.extensionsByMessage[message] == nil {
-		r.extensionsByMessage[message] = make(extensionsByNumber)
-	}
-	r.extensionsByMessage[message][field] = xt
-	r.numExtensions++
-	return nil
-}
-
-func (r *Types) register(kind string, desc protoreflect.Descriptor, typ interface{}) error {
-	name := desc.FullName()
-	prev := r.typesByName[name]
-	if prev != nil {
-		err := errors.New("%v %v is already registered", kind, name)
-		err = amendErrorWithCaller(err, prev, typ)
-		if !(r == GlobalTypes && ignoreConflict(desc, err)) {
-			return err
-		}
-	}
-	if r.typesByName == nil {
-		r.typesByName = make(typesByName)
-	}
-	r.typesByName[name] = typ
-	return nil
-}
-
-// FindEnumByName looks up an enum by its full name.
-// E.g., "google.protobuf.Field.Kind".
-//
-// This returns (nil, NotFound) if not found.
-func (r *Types) FindEnumByName(enum protoreflect.FullName) (protoreflect.EnumType, error) {
-	if r == nil {
-		return nil, NotFound
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	if v := r.typesByName[enum]; v != nil {
-		if et, _ := v.(protoreflect.EnumType); et != nil {
-			return et, nil
-		}
-		return nil, errors.New("found wrong type: got %v, want enum", typeName(v))
-	}
-	return nil, NotFound
-}
-
-// FindMessageByName looks up a message by its full name.
-// E.g., "google.protobuf.Any"
-//
-// This return (nil, NotFound) if not found.
-func (r *Types) FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) {
-	// The full name by itself is a valid URL.
-	return r.FindMessageByURL(string(message))
-}
-
-// FindMessageByURL looks up a message by a URL identifier.
-// See documentation on google.protobuf.Any.type_url for the URL format.
-//
-// This returns (nil, NotFound) if not found.
-func (r *Types) FindMessageByURL(url string) (protoreflect.MessageType, error) {
-	if r == nil {
-		return nil, NotFound
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	message := protoreflect.FullName(url)
-	if i := strings.LastIndexByte(url, '/'); i >= 0 {
-		message = message[i+len("/"):]
-	}
-
-	if v := r.typesByName[message]; v != nil {
-		if mt, _ := v.(protoreflect.MessageType); mt != nil {
-			return mt, nil
-		}
-		return nil, errors.New("found wrong type: got %v, want message", typeName(v))
-	}
-	return nil, NotFound
-}
-
-// FindExtensionByName looks up a extension field by the field's full name.
-// Note that this is the full name of the field as determined by
-// where the extension is declared and is unrelated to the full name of the
-// message being extended.
-//
-// This returns (nil, NotFound) if not found.
-func (r *Types) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) {
-	if r == nil {
-		return nil, NotFound
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	if v := r.typesByName[field]; v != nil {
-		if xt, _ := v.(protoreflect.ExtensionType); xt != nil {
-			return xt, nil
-		}
-		return nil, errors.New("found wrong type: got %v, want extension", typeName(v))
-	}
-	return nil, NotFound
-}
-
-// FindExtensionByNumber looks up a extension field by the field number
-// within some parent message, identified by full name.
-//
-// This returns (nil, NotFound) if not found.
-func (r *Types) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) {
-	if r == nil {
-		return nil, NotFound
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	if xt, ok := r.extensionsByMessage[message][field]; ok {
-		return xt, nil
-	}
-	return nil, NotFound
-}
-
-// NumEnums reports the number of registered enums.
-func (r *Types) NumEnums() int {
-	if r == nil {
-		return 0
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	return r.numEnums
-}
-
-// RangeEnums iterates over all registered enums while f returns true.
-// Iteration order is undefined.
-func (r *Types) RangeEnums(f func(protoreflect.EnumType) bool) {
-	if r == nil {
-		return
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	for _, typ := range r.typesByName {
-		if et, ok := typ.(protoreflect.EnumType); ok {
-			if !f(et) {
-				return
-			}
-		}
-	}
-}
-
-// NumMessages reports the number of registered messages.
-func (r *Types) NumMessages() int {
-	if r == nil {
-		return 0
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	return r.numMessages
-}
-
-// RangeMessages iterates over all registered messages while f returns true.
-// Iteration order is undefined.
-func (r *Types) RangeMessages(f func(protoreflect.MessageType) bool) {
-	if r == nil {
-		return
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	for _, typ := range r.typesByName {
-		if mt, ok := typ.(protoreflect.MessageType); ok {
-			if !f(mt) {
-				return
-			}
-		}
-	}
-}
-
-// NumExtensions reports the number of registered extensions.
-func (r *Types) NumExtensions() int {
-	if r == nil {
-		return 0
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	return r.numExtensions
-}
-
-// RangeExtensions iterates over all registered extensions while f returns true.
-// Iteration order is undefined.
-func (r *Types) RangeExtensions(f func(protoreflect.ExtensionType) bool) {
-	if r == nil {
-		return
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	for _, typ := range r.typesByName {
-		if xt, ok := typ.(protoreflect.ExtensionType); ok {
-			if !f(xt) {
-				return
-			}
-		}
-	}
-}
-
-// NumExtensionsByMessage reports the number of registered extensions for
-// a given message type.
-func (r *Types) NumExtensionsByMessage(message protoreflect.FullName) int {
-	if r == nil {
-		return 0
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	return len(r.extensionsByMessage[message])
-}
-
-// RangeExtensionsByMessage iterates over all registered extensions filtered
-// by a given message type while f returns true. Iteration order is undefined.
-func (r *Types) RangeExtensionsByMessage(message protoreflect.FullName, f func(protoreflect.ExtensionType) bool) {
-	if r == nil {
-		return
-	}
-	if r == GlobalTypes {
-		globalMutex.RLock()
-		defer globalMutex.RUnlock()
-	}
-	for _, xt := range r.extensionsByMessage[message] {
-		if !f(xt) {
-			return
-		}
-	}
-}
-
-func typeName(t interface{}) string {
-	switch t.(type) {
-	case protoreflect.EnumType:
-		return "enum"
-	case protoreflect.MessageType:
-		return "message"
-	case protoreflect.ExtensionType:
-		return "extension"
-	default:
-		return fmt.Sprintf("%T", t)
-	}
-}
-
-func amendErrorWithCaller(err error, prev, curr interface{}) error {
-	prevPkg := goPackage(prev)
-	currPkg := goPackage(curr)
-	if prevPkg == "" || currPkg == "" || prevPkg == currPkg {
-		return err
-	}
-	return errors.New("%s\n\tpreviously from: %q\n\tcurrently from:  %q", err, prevPkg, currPkg)
-}
-
-func goPackage(v interface{}) string {
-	switch d := v.(type) {
-	case protoreflect.EnumType:
-		v = d.Descriptor()
-	case protoreflect.MessageType:
-		v = d.Descriptor()
-	case protoreflect.ExtensionType:
-		v = d.TypeDescriptor()
-	}
-	if d, ok := v.(protoreflect.Descriptor); ok {
-		v = d.ParentFile()
-	}
-	if d, ok := v.(interface{ GoPackagePath() string }); ok {
-		return d.GoPackagePath()
-	}
-	return ""
-}
diff --git a/vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go b/vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go
deleted file mode 100644
index c587276..0000000
--- a/vendor/google.golang.org/protobuf/runtime/protoiface/legacy.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoiface
-
-type MessageV1 interface {
-	Reset()
-	String() string
-	ProtoMessage()
-}
-
-type ExtensionRangeV1 struct {
-	Start, End int32 // both inclusive
-}
diff --git a/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go b/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go
deleted file mode 100644
index 32c04f6..0000000
--- a/vendor/google.golang.org/protobuf/runtime/protoiface/methods.go
+++ /dev/null
@@ -1,167 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protoiface contains types referenced or implemented by messages.
-//
-// WARNING: This package should only be imported by message implementations.
-// The functionality found in this package should be accessed through
-// higher-level abstractions provided by the proto package.
-package protoiface
-
-import (
-	"google.golang.org/protobuf/internal/pragma"
-	"google.golang.org/protobuf/reflect/protoreflect"
-)
-
-// Methods is a set of optional fast-path implementations of various operations.
-type Methods = struct {
-	pragma.NoUnkeyedLiterals
-
-	// Flags indicate support for optional features.
-	Flags SupportFlags
-
-	// Size returns the size in bytes of the wire-format encoding of a message.
-	// Marshal must be provided if a custom Size is provided.
-	Size func(SizeInput) SizeOutput
-
-	// Marshal formats a message in the wire-format encoding to the provided buffer.
-	// Size should be provided if a custom Marshal is provided.
-	// It must not return an error for a partial message.
-	Marshal func(MarshalInput) (MarshalOutput, error)
-
-	// Unmarshal parses the wire-format encoding and merges the result into a message.
-	// It must not reset the target message or return an error for a partial message.
-	Unmarshal func(UnmarshalInput) (UnmarshalOutput, error)
-
-	// Merge merges the contents of a source message into a destination message.
-	Merge func(MergeInput) MergeOutput
-
-	// CheckInitialized returns an error if any required fields in the message are not set.
-	CheckInitialized func(CheckInitializedInput) (CheckInitializedOutput, error)
-}
-
-// SupportFlags indicate support for optional features.
-type SupportFlags = uint64
-
-const (
-	// SupportMarshalDeterministic reports whether MarshalOptions.Deterministic is supported.
-	SupportMarshalDeterministic SupportFlags = 1 << iota
-
-	// SupportUnmarshalDiscardUnknown reports whether UnmarshalOptions.DiscardUnknown is supported.
-	SupportUnmarshalDiscardUnknown
-)
-
-// SizeInput is input to the Size method.
-type SizeInput = struct {
-	pragma.NoUnkeyedLiterals
-
-	Message protoreflect.Message
-	Flags   MarshalInputFlags
-}
-
-// SizeOutput is output from the Size method.
-type SizeOutput = struct {
-	pragma.NoUnkeyedLiterals
-
-	Size int
-}
-
-// MarshalInput is input to the Marshal method.
-type MarshalInput = struct {
-	pragma.NoUnkeyedLiterals
-
-	Message protoreflect.Message
-	Buf     []byte // output is appended to this buffer
-	Flags   MarshalInputFlags
-}
-
-// MarshalOutput is output from the Marshal method.
-type MarshalOutput = struct {
-	pragma.NoUnkeyedLiterals
-
-	Buf []byte // contains marshaled message
-}
-
-// MarshalInputFlags configure the marshaler.
-// Most flags correspond to fields in proto.MarshalOptions.
-type MarshalInputFlags = uint8
-
-const (
-	MarshalDeterministic MarshalInputFlags = 1 << iota
-	MarshalUseCachedSize
-)
-
-// UnmarshalInput is input to the Unmarshal method.
-type UnmarshalInput = struct {
-	pragma.NoUnkeyedLiterals
-
-	Message  protoreflect.Message
-	Buf      []byte // input buffer
-	Flags    UnmarshalInputFlags
-	Resolver interface {
-		FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
-		FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
-	}
-}
-
-// UnmarshalOutput is output from the Unmarshal method.
-type UnmarshalOutput = struct {
-	pragma.NoUnkeyedLiterals
-
-	Flags UnmarshalOutputFlags
-}
-
-// UnmarshalInputFlags configure the unmarshaler.
-// Most flags correspond to fields in proto.UnmarshalOptions.
-type UnmarshalInputFlags = uint8
-
-const (
-	UnmarshalDiscardUnknown UnmarshalInputFlags = 1 << iota
-)
-
-// UnmarshalOutputFlags are output from the Unmarshal method.
-type UnmarshalOutputFlags = uint8
-
-const (
-	// UnmarshalInitialized may be set on return if all required fields are known to be set.
-	// If unset, then it does not necessarily indicate that the message is uninitialized,
-	// only that its status could not be confirmed.
-	UnmarshalInitialized UnmarshalOutputFlags = 1 << iota
-)
-
-// MergeInput is input to the Merge method.
-type MergeInput = struct {
-	pragma.NoUnkeyedLiterals
-
-	Source      protoreflect.Message
-	Destination protoreflect.Message
-}
-
-// MergeOutput is output from the Merge method.
-type MergeOutput = struct {
-	pragma.NoUnkeyedLiterals
-
-	Flags MergeOutputFlags
-}
-
-// MergeOutputFlags are output from the Merge method.
-type MergeOutputFlags = uint8
-
-const (
-	// MergeComplete reports whether the merge was performed.
-	// If unset, the merger must have made no changes to the destination.
-	MergeComplete MergeOutputFlags = 1 << iota
-)
-
-// CheckInitializedInput is input to the CheckInitialized method.
-type CheckInitializedInput = struct {
-	pragma.NoUnkeyedLiterals
-
-	Message protoreflect.Message
-}
-
-// CheckInitializedOutput is output from the CheckInitialized method.
-type CheckInitializedOutput = struct {
-	pragma.NoUnkeyedLiterals
-}
diff --git a/vendor/google.golang.org/protobuf/runtime/protoimpl/impl.go b/vendor/google.golang.org/protobuf/runtime/protoimpl/impl.go
deleted file mode 100644
index 4a1ab7f..0000000
--- a/vendor/google.golang.org/protobuf/runtime/protoimpl/impl.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package protoimpl contains the default implementation for messages
-// generated by protoc-gen-go.
-//
-// WARNING: This package should only ever be imported by generated messages.
-// The compatibility agreement covers nothing except for functionality needed
-// to keep existing generated messages operational. Breakages that occur due
-// to unauthorized usages of this package are not the author's responsibility.
-package protoimpl
-
-import (
-	"google.golang.org/protobuf/internal/filedesc"
-	"google.golang.org/protobuf/internal/filetype"
-	"google.golang.org/protobuf/internal/impl"
-)
-
-// UnsafeEnabled specifies whether package unsafe can be used.
-const UnsafeEnabled = impl.UnsafeEnabled
-
-type (
-	// Types used by generated code in init functions.
-	DescBuilder = filedesc.Builder
-	TypeBuilder = filetype.Builder
-
-	// Types used by generated code to implement EnumType, MessageType, and ExtensionType.
-	EnumInfo      = impl.EnumInfo
-	MessageInfo   = impl.MessageInfo
-	ExtensionInfo = impl.ExtensionInfo
-
-	// Types embedded in generated messages.
-	MessageState     = impl.MessageState
-	SizeCache        = impl.SizeCache
-	WeakFields       = impl.WeakFields
-	UnknownFields    = impl.UnknownFields
-	ExtensionFields  = impl.ExtensionFields
-	ExtensionFieldV1 = impl.ExtensionField
-
-	Pointer = impl.Pointer
-)
-
-var X impl.Export
diff --git a/vendor/google.golang.org/protobuf/runtime/protoimpl/version.go b/vendor/google.golang.org/protobuf/runtime/protoimpl/version.go
deleted file mode 100644
index ff094e1..0000000
--- a/vendor/google.golang.org/protobuf/runtime/protoimpl/version.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package protoimpl
-
-import (
-	"google.golang.org/protobuf/internal/version"
-)
-
-const (
-	// MaxVersion is the maximum supported version for generated .pb.go files.
-	// It is always the current version of the module.
-	MaxVersion = version.Minor
-
-	// GenVersion is the runtime version required by generated .pb.go files.
-	// This is incremented when generated code relies on new functionality
-	// in the runtime.
-	GenVersion = 20
-
-	// MinVersion is the minimum supported version for generated .pb.go files.
-	// This is incremented when the runtime drops support for old code.
-	MinVersion = 0
-)
-
-// EnforceVersion is used by code generated by protoc-gen-go
-// to statically enforce minimum and maximum versions of this package.
-// A compilation failure implies either that:
-//	* the runtime package is too old and needs to be updated OR
-//	* the generated code is too old and needs to be regenerated.
-//
-// The runtime package can be upgraded by running:
-//	go get google.golang.org/protobuf
-//
-// The generated code can be regenerated by running:
-//	protoc --go_out=${PROTOC_GEN_GO_ARGS} ${PROTO_FILES}
-//
-// Example usage by generated code:
-//	const (
-//		// Verify that this generated code is sufficiently up-to-date.
-//		_ = protoimpl.EnforceVersion(genVersion - protoimpl.MinVersion)
-//		// Verify that runtime/protoimpl is sufficiently up-to-date.
-//		_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - genVersion)
-//	)
-//
-// The genVersion is the current minor version used to generated the code.
-// This compile-time check relies on negative integer overflow of a uint
-// being a compilation failure (guaranteed by the Go specification).
-type EnforceVersion uint
-
-// This enforces the following invariant:
-//	MinVersion ≤ GenVersion ≤ MaxVersion
-const (
-	_ = EnforceVersion(GenVersion - MinVersion)
-	_ = EnforceVersion(MaxVersion - GenVersion)
-)
diff --git a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go b/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
deleted file mode 100644
index 8242378..0000000
--- a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
+++ /dev/null
@@ -1,4040 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Author: kenton@google.com (Kenton Varda)
-//  Based on original Protocol Buffers design by
-//  Sanjay Ghemawat, Jeff Dean, and others.
-//
-// The messages in this file describe the definitions found in .proto files.
-// A valid .proto file can be translated directly to a FileDescriptorProto
-// without any other information (e.g. without reading its imports).
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/descriptor.proto
-
-package descriptorpb
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoiface "google.golang.org/protobuf/runtime/protoiface"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-type FieldDescriptorProto_Type int32
-
-const (
-	// 0 is reserved for errors.
-	// Order is weird for historical reasons.
-	FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1
-	FieldDescriptorProto_TYPE_FLOAT  FieldDescriptorProto_Type = 2
-	// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
-	// negative values are likely.
-	FieldDescriptorProto_TYPE_INT64  FieldDescriptorProto_Type = 3
-	FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4
-	// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
-	// negative values are likely.
-	FieldDescriptorProto_TYPE_INT32   FieldDescriptorProto_Type = 5
-	FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6
-	FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7
-	FieldDescriptorProto_TYPE_BOOL    FieldDescriptorProto_Type = 8
-	FieldDescriptorProto_TYPE_STRING  FieldDescriptorProto_Type = 9
-	// Tag-delimited aggregate.
-	// Group type is deprecated and not supported in proto3. However, Proto3
-	// implementations should still be able to parse the group wire format and
-	// treat group fields as unknown fields.
-	FieldDescriptorProto_TYPE_GROUP   FieldDescriptorProto_Type = 10
-	FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11 // Length-delimited aggregate.
-	// New in version 2.
-	FieldDescriptorProto_TYPE_BYTES    FieldDescriptorProto_Type = 12
-	FieldDescriptorProto_TYPE_UINT32   FieldDescriptorProto_Type = 13
-	FieldDescriptorProto_TYPE_ENUM     FieldDescriptorProto_Type = 14
-	FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15
-	FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16
-	FieldDescriptorProto_TYPE_SINT32   FieldDescriptorProto_Type = 17 // Uses ZigZag encoding.
-	FieldDescriptorProto_TYPE_SINT64   FieldDescriptorProto_Type = 18 // Uses ZigZag encoding.
-)
-
-// Enum value maps for FieldDescriptorProto_Type.
-var (
-	FieldDescriptorProto_Type_name = map[int32]string{
-		1:  "TYPE_DOUBLE",
-		2:  "TYPE_FLOAT",
-		3:  "TYPE_INT64",
-		4:  "TYPE_UINT64",
-		5:  "TYPE_INT32",
-		6:  "TYPE_FIXED64",
-		7:  "TYPE_FIXED32",
-		8:  "TYPE_BOOL",
-		9:  "TYPE_STRING",
-		10: "TYPE_GROUP",
-		11: "TYPE_MESSAGE",
-		12: "TYPE_BYTES",
-		13: "TYPE_UINT32",
-		14: "TYPE_ENUM",
-		15: "TYPE_SFIXED32",
-		16: "TYPE_SFIXED64",
-		17: "TYPE_SINT32",
-		18: "TYPE_SINT64",
-	}
-	FieldDescriptorProto_Type_value = map[string]int32{
-		"TYPE_DOUBLE":   1,
-		"TYPE_FLOAT":    2,
-		"TYPE_INT64":    3,
-		"TYPE_UINT64":   4,
-		"TYPE_INT32":    5,
-		"TYPE_FIXED64":  6,
-		"TYPE_FIXED32":  7,
-		"TYPE_BOOL":     8,
-		"TYPE_STRING":   9,
-		"TYPE_GROUP":    10,
-		"TYPE_MESSAGE":  11,
-		"TYPE_BYTES":    12,
-		"TYPE_UINT32":   13,
-		"TYPE_ENUM":     14,
-		"TYPE_SFIXED32": 15,
-		"TYPE_SFIXED64": 16,
-		"TYPE_SINT32":   17,
-		"TYPE_SINT64":   18,
-	}
-)
-
-func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type {
-	p := new(FieldDescriptorProto_Type)
-	*p = x
-	return p
-}
-
-func (x FieldDescriptorProto_Type) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (FieldDescriptorProto_Type) Descriptor() protoreflect.EnumDescriptor {
-	return file_google_protobuf_descriptor_proto_enumTypes[0].Descriptor()
-}
-
-func (FieldDescriptorProto_Type) Type() protoreflect.EnumType {
-	return &file_google_protobuf_descriptor_proto_enumTypes[0]
-}
-
-func (x FieldDescriptorProto_Type) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *FieldDescriptorProto_Type) UnmarshalJSON(b []byte) error {
-	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
-	if err != nil {
-		return err
-	}
-	*x = FieldDescriptorProto_Type(num)
-	return nil
-}
-
-// Deprecated: Use FieldDescriptorProto_Type.Descriptor instead.
-func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4, 0}
-}
-
-type FieldDescriptorProto_Label int32
-
-const (
-	// 0 is reserved for errors
-	FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1
-	FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2
-	FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3
-)
-
-// Enum value maps for FieldDescriptorProto_Label.
-var (
-	FieldDescriptorProto_Label_name = map[int32]string{
-		1: "LABEL_OPTIONAL",
-		2: "LABEL_REQUIRED",
-		3: "LABEL_REPEATED",
-	}
-	FieldDescriptorProto_Label_value = map[string]int32{
-		"LABEL_OPTIONAL": 1,
-		"LABEL_REQUIRED": 2,
-		"LABEL_REPEATED": 3,
-	}
-)
-
-func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label {
-	p := new(FieldDescriptorProto_Label)
-	*p = x
-	return p
-}
-
-func (x FieldDescriptorProto_Label) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (FieldDescriptorProto_Label) Descriptor() protoreflect.EnumDescriptor {
-	return file_google_protobuf_descriptor_proto_enumTypes[1].Descriptor()
-}
-
-func (FieldDescriptorProto_Label) Type() protoreflect.EnumType {
-	return &file_google_protobuf_descriptor_proto_enumTypes[1]
-}
-
-func (x FieldDescriptorProto_Label) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *FieldDescriptorProto_Label) UnmarshalJSON(b []byte) error {
-	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
-	if err != nil {
-		return err
-	}
-	*x = FieldDescriptorProto_Label(num)
-	return nil
-}
-
-// Deprecated: Use FieldDescriptorProto_Label.Descriptor instead.
-func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4, 1}
-}
-
-// Generated classes can be optimized for speed or code size.
-type FileOptions_OptimizeMode int32
-
-const (
-	FileOptions_SPEED FileOptions_OptimizeMode = 1 // Generate complete code for parsing, serialization,
-	// etc.
-	FileOptions_CODE_SIZE    FileOptions_OptimizeMode = 2 // Use ReflectionOps to implement these methods.
-	FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 // Generate code using MessageLite and the lite runtime.
-)
-
-// Enum value maps for FileOptions_OptimizeMode.
-var (
-	FileOptions_OptimizeMode_name = map[int32]string{
-		1: "SPEED",
-		2: "CODE_SIZE",
-		3: "LITE_RUNTIME",
-	}
-	FileOptions_OptimizeMode_value = map[string]int32{
-		"SPEED":        1,
-		"CODE_SIZE":    2,
-		"LITE_RUNTIME": 3,
-	}
-)
-
-func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode {
-	p := new(FileOptions_OptimizeMode)
-	*p = x
-	return p
-}
-
-func (x FileOptions_OptimizeMode) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (FileOptions_OptimizeMode) Descriptor() protoreflect.EnumDescriptor {
-	return file_google_protobuf_descriptor_proto_enumTypes[2].Descriptor()
-}
-
-func (FileOptions_OptimizeMode) Type() protoreflect.EnumType {
-	return &file_google_protobuf_descriptor_proto_enumTypes[2]
-}
-
-func (x FileOptions_OptimizeMode) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *FileOptions_OptimizeMode) UnmarshalJSON(b []byte) error {
-	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
-	if err != nil {
-		return err
-	}
-	*x = FileOptions_OptimizeMode(num)
-	return nil
-}
-
-// Deprecated: Use FileOptions_OptimizeMode.Descriptor instead.
-func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{10, 0}
-}
-
-type FieldOptions_CType int32
-
-const (
-	// Default mode.
-	FieldOptions_STRING       FieldOptions_CType = 0
-	FieldOptions_CORD         FieldOptions_CType = 1
-	FieldOptions_STRING_PIECE FieldOptions_CType = 2
-)
-
-// Enum value maps for FieldOptions_CType.
-var (
-	FieldOptions_CType_name = map[int32]string{
-		0: "STRING",
-		1: "CORD",
-		2: "STRING_PIECE",
-	}
-	FieldOptions_CType_value = map[string]int32{
-		"STRING":       0,
-		"CORD":         1,
-		"STRING_PIECE": 2,
-	}
-)
-
-func (x FieldOptions_CType) Enum() *FieldOptions_CType {
-	p := new(FieldOptions_CType)
-	*p = x
-	return p
-}
-
-func (x FieldOptions_CType) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (FieldOptions_CType) Descriptor() protoreflect.EnumDescriptor {
-	return file_google_protobuf_descriptor_proto_enumTypes[3].Descriptor()
-}
-
-func (FieldOptions_CType) Type() protoreflect.EnumType {
-	return &file_google_protobuf_descriptor_proto_enumTypes[3]
-}
-
-func (x FieldOptions_CType) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *FieldOptions_CType) UnmarshalJSON(b []byte) error {
-	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
-	if err != nil {
-		return err
-	}
-	*x = FieldOptions_CType(num)
-	return nil
-}
-
-// Deprecated: Use FieldOptions_CType.Descriptor instead.
-func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 0}
-}
-
-type FieldOptions_JSType int32
-
-const (
-	// Use the default type.
-	FieldOptions_JS_NORMAL FieldOptions_JSType = 0
-	// Use JavaScript strings.
-	FieldOptions_JS_STRING FieldOptions_JSType = 1
-	// Use JavaScript numbers.
-	FieldOptions_JS_NUMBER FieldOptions_JSType = 2
-)
-
-// Enum value maps for FieldOptions_JSType.
-var (
-	FieldOptions_JSType_name = map[int32]string{
-		0: "JS_NORMAL",
-		1: "JS_STRING",
-		2: "JS_NUMBER",
-	}
-	FieldOptions_JSType_value = map[string]int32{
-		"JS_NORMAL": 0,
-		"JS_STRING": 1,
-		"JS_NUMBER": 2,
-	}
-)
-
-func (x FieldOptions_JSType) Enum() *FieldOptions_JSType {
-	p := new(FieldOptions_JSType)
-	*p = x
-	return p
-}
-
-func (x FieldOptions_JSType) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (FieldOptions_JSType) Descriptor() protoreflect.EnumDescriptor {
-	return file_google_protobuf_descriptor_proto_enumTypes[4].Descriptor()
-}
-
-func (FieldOptions_JSType) Type() protoreflect.EnumType {
-	return &file_google_protobuf_descriptor_proto_enumTypes[4]
-}
-
-func (x FieldOptions_JSType) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *FieldOptions_JSType) UnmarshalJSON(b []byte) error {
-	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
-	if err != nil {
-		return err
-	}
-	*x = FieldOptions_JSType(num)
-	return nil
-}
-
-// Deprecated: Use FieldOptions_JSType.Descriptor instead.
-func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 1}
-}
-
-// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
-// or neither? HTTP based RPC implementation may choose GET verb for safe
-// methods, and PUT verb for idempotent methods instead of the default POST.
-type MethodOptions_IdempotencyLevel int32
-
-const (
-	MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0
-	MethodOptions_NO_SIDE_EFFECTS     MethodOptions_IdempotencyLevel = 1 // implies idempotent
-	MethodOptions_IDEMPOTENT          MethodOptions_IdempotencyLevel = 2 // idempotent, but may have side effects
-)
-
-// Enum value maps for MethodOptions_IdempotencyLevel.
-var (
-	MethodOptions_IdempotencyLevel_name = map[int32]string{
-		0: "IDEMPOTENCY_UNKNOWN",
-		1: "NO_SIDE_EFFECTS",
-		2: "IDEMPOTENT",
-	}
-	MethodOptions_IdempotencyLevel_value = map[string]int32{
-		"IDEMPOTENCY_UNKNOWN": 0,
-		"NO_SIDE_EFFECTS":     1,
-		"IDEMPOTENT":          2,
-	}
-)
-
-func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel {
-	p := new(MethodOptions_IdempotencyLevel)
-	*p = x
-	return p
-}
-
-func (x MethodOptions_IdempotencyLevel) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (MethodOptions_IdempotencyLevel) Descriptor() protoreflect.EnumDescriptor {
-	return file_google_protobuf_descriptor_proto_enumTypes[5].Descriptor()
-}
-
-func (MethodOptions_IdempotencyLevel) Type() protoreflect.EnumType {
-	return &file_google_protobuf_descriptor_proto_enumTypes[5]
-}
-
-func (x MethodOptions_IdempotencyLevel) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(b []byte) error {
-	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
-	if err != nil {
-		return err
-	}
-	*x = MethodOptions_IdempotencyLevel(num)
-	return nil
-}
-
-// Deprecated: Use MethodOptions_IdempotencyLevel.Descriptor instead.
-func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{17, 0}
-}
-
-// The protocol compiler can output a FileDescriptorSet containing the .proto
-// files it parses.
-type FileDescriptorSet struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"`
-}
-
-func (x *FileDescriptorSet) Reset() {
-	*x = FileDescriptorSet{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *FileDescriptorSet) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FileDescriptorSet) ProtoMessage() {}
-
-func (x *FileDescriptorSet) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use FileDescriptorSet.ProtoReflect.Descriptor instead.
-func (*FileDescriptorSet) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *FileDescriptorSet) GetFile() []*FileDescriptorProto {
-	if x != nil {
-		return x.File
-	}
-	return nil
-}
-
-// Describes a complete .proto file.
-type FileDescriptorProto struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Name    *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`       // file name, relative to root of source tree
-	Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"` // e.g. "foo", "foo.bar", etc.
-	// Names of files imported by this file.
-	Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"`
-	// Indexes of the public imported files in the dependency list above.
-	PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"`
-	// Indexes of the weak imported files in the dependency list.
-	// For Google-internal migration only. Do not use.
-	WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
-	// All top-level definitions in this file.
-	MessageType []*DescriptorProto        `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
-	EnumType    []*EnumDescriptorProto    `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
-	Service     []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"`
-	Extension   []*FieldDescriptorProto   `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"`
-	Options     *FileOptions              `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
-	// This field contains optional information about the original source code.
-	// You may safely remove this entire field without harming runtime
-	// functionality of the descriptors -- the information is needed only by
-	// development tools.
-	SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"`
-	// The syntax of the proto file.
-	// The supported values are "proto2" and "proto3".
-	Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"`
-}
-
-func (x *FileDescriptorProto) Reset() {
-	*x = FileDescriptorProto{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *FileDescriptorProto) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FileDescriptorProto) ProtoMessage() {}
-
-func (x *FileDescriptorProto) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use FileDescriptorProto.ProtoReflect.Descriptor instead.
-func (*FileDescriptorProto) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *FileDescriptorProto) GetName() string {
-	if x != nil && x.Name != nil {
-		return *x.Name
-	}
-	return ""
-}
-
-func (x *FileDescriptorProto) GetPackage() string {
-	if x != nil && x.Package != nil {
-		return *x.Package
-	}
-	return ""
-}
-
-func (x *FileDescriptorProto) GetDependency() []string {
-	if x != nil {
-		return x.Dependency
-	}
-	return nil
-}
-
-func (x *FileDescriptorProto) GetPublicDependency() []int32 {
-	if x != nil {
-		return x.PublicDependency
-	}
-	return nil
-}
-
-func (x *FileDescriptorProto) GetWeakDependency() []int32 {
-	if x != nil {
-		return x.WeakDependency
-	}
-	return nil
-}
-
-func (x *FileDescriptorProto) GetMessageType() []*DescriptorProto {
-	if x != nil {
-		return x.MessageType
-	}
-	return nil
-}
-
-func (x *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto {
-	if x != nil {
-		return x.EnumType
-	}
-	return nil
-}
-
-func (x *FileDescriptorProto) GetService() []*ServiceDescriptorProto {
-	if x != nil {
-		return x.Service
-	}
-	return nil
-}
-
-func (x *FileDescriptorProto) GetExtension() []*FieldDescriptorProto {
-	if x != nil {
-		return x.Extension
-	}
-	return nil
-}
-
-func (x *FileDescriptorProto) GetOptions() *FileOptions {
-	if x != nil {
-		return x.Options
-	}
-	return nil
-}
-
-func (x *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo {
-	if x != nil {
-		return x.SourceCodeInfo
-	}
-	return nil
-}
-
-func (x *FileDescriptorProto) GetSyntax() string {
-	if x != nil && x.Syntax != nil {
-		return *x.Syntax
-	}
-	return ""
-}
-
-// Describes a message type.
-type DescriptorProto struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Name           *string                           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Field          []*FieldDescriptorProto           `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
-	Extension      []*FieldDescriptorProto           `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"`
-	NestedType     []*DescriptorProto                `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"`
-	EnumType       []*EnumDescriptorProto            `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
-	ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"`
-	OneofDecl      []*OneofDescriptorProto           `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"`
-	Options        *MessageOptions                   `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"`
-	ReservedRange  []*DescriptorProto_ReservedRange  `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
-	// Reserved field names, which may not be used by fields in the same message.
-	// A given name may only be reserved once.
-	ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
-}
-
-func (x *DescriptorProto) Reset() {
-	*x = DescriptorProto{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DescriptorProto) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DescriptorProto) ProtoMessage() {}
-
-func (x *DescriptorProto) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DescriptorProto.ProtoReflect.Descriptor instead.
-func (*DescriptorProto) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *DescriptorProto) GetName() string {
-	if x != nil && x.Name != nil {
-		return *x.Name
-	}
-	return ""
-}
-
-func (x *DescriptorProto) GetField() []*FieldDescriptorProto {
-	if x != nil {
-		return x.Field
-	}
-	return nil
-}
-
-func (x *DescriptorProto) GetExtension() []*FieldDescriptorProto {
-	if x != nil {
-		return x.Extension
-	}
-	return nil
-}
-
-func (x *DescriptorProto) GetNestedType() []*DescriptorProto {
-	if x != nil {
-		return x.NestedType
-	}
-	return nil
-}
-
-func (x *DescriptorProto) GetEnumType() []*EnumDescriptorProto {
-	if x != nil {
-		return x.EnumType
-	}
-	return nil
-}
-
-func (x *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange {
-	if x != nil {
-		return x.ExtensionRange
-	}
-	return nil
-}
-
-func (x *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto {
-	if x != nil {
-		return x.OneofDecl
-	}
-	return nil
-}
-
-func (x *DescriptorProto) GetOptions() *MessageOptions {
-	if x != nil {
-		return x.Options
-	}
-	return nil
-}
-
-func (x *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange {
-	if x != nil {
-		return x.ReservedRange
-	}
-	return nil
-}
-
-func (x *DescriptorProto) GetReservedName() []string {
-	if x != nil {
-		return x.ReservedName
-	}
-	return nil
-}
-
-type ExtensionRangeOptions struct {
-	state           protoimpl.MessageState
-	sizeCache       protoimpl.SizeCache
-	unknownFields   protoimpl.UnknownFields
-	extensionFields protoimpl.ExtensionFields
-
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-func (x *ExtensionRangeOptions) Reset() {
-	*x = ExtensionRangeOptions{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ExtensionRangeOptions) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ExtensionRangeOptions) ProtoMessage() {}
-
-func (x *ExtensionRangeOptions) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ExtensionRangeOptions.ProtoReflect.Descriptor instead.
-func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{3}
-}
-
-var extRange_ExtensionRangeOptions = []protoiface.ExtensionRangeV1{
-	{Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use ExtensionRangeOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*ExtensionRangeOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
-	return extRange_ExtensionRangeOptions
-}
-
-func (x *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if x != nil {
-		return x.UninterpretedOption
-	}
-	return nil
-}
-
-// Describes a field within a message.
-type FieldDescriptorProto struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Name   *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Number *int32                      `protobuf:"varint,3,opt,name=number" json:"number,omitempty"`
-	Label  *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"`
-	// If type_name is set, this need not be set.  If both this and type_name
-	// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
-	Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"`
-	// For message and enum types, this is the name of the type.  If the name
-	// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
-	// rules are used to find the type (i.e. first the nested types within this
-	// message are searched, then within the parent, on up to the root
-	// namespace).
-	TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
-	// For extensions, this is the name of the type being extended.  It is
-	// resolved in the same manner as type_name.
-	Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"`
-	// For numeric types, contains the original text representation of the value.
-	// For booleans, "true" or "false".
-	// For strings, contains the default text contents (not escaped in any way).
-	// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
-	// TODO(kenton):  Base-64 encode?
-	DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"`
-	// If set, gives the index of a oneof in the containing type's oneof_decl
-	// list.  This field is a member of that oneof.
-	OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"`
-	// JSON name of this field. The value is set by protocol compiler. If the
-	// user has set a "json_name" option on this field, that option's value
-	// will be used. Otherwise, it's deduced from the field's name by converting
-	// it to camelCase.
-	JsonName *string       `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"`
-	Options  *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
-	// If true, this is a proto3 "optional". When a proto3 field is optional, it
-	// tracks presence regardless of field type.
-	//
-	// When proto3_optional is true, this field must be belong to a oneof to
-	// signal to old proto3 clients that presence is tracked for this field. This
-	// oneof is known as a "synthetic" oneof, and this field must be its sole
-	// member (each proto3 optional field gets its own synthetic oneof). Synthetic
-	// oneofs exist in the descriptor only, and do not generate any API. Synthetic
-	// oneofs must be ordered after all "real" oneofs.
-	//
-	// For message fields, proto3_optional doesn't create any semantic change,
-	// since non-repeated message fields always track presence. However it still
-	// indicates the semantic detail of whether the user wrote "optional" or not.
-	// This can be useful for round-tripping the .proto file. For consistency we
-	// give message fields a synthetic oneof also, even though it is not required
-	// to track presence. This is especially important because the parser can't
-	// tell if a field is a message or an enum, so it must always create a
-	// synthetic oneof.
-	//
-	// Proto2 optional fields do not set this flag, because they already indicate
-	// optional with `LABEL_OPTIONAL`.
-	Proto3Optional *bool `protobuf:"varint,17,opt,name=proto3_optional,json=proto3Optional" json:"proto3_optional,omitempty"`
-}
-
-func (x *FieldDescriptorProto) Reset() {
-	*x = FieldDescriptorProto{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *FieldDescriptorProto) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FieldDescriptorProto) ProtoMessage() {}
-
-func (x *FieldDescriptorProto) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[4]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use FieldDescriptorProto.ProtoReflect.Descriptor instead.
-func (*FieldDescriptorProto) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *FieldDescriptorProto) GetName() string {
-	if x != nil && x.Name != nil {
-		return *x.Name
-	}
-	return ""
-}
-
-func (x *FieldDescriptorProto) GetNumber() int32 {
-	if x != nil && x.Number != nil {
-		return *x.Number
-	}
-	return 0
-}
-
-func (x *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label {
-	if x != nil && x.Label != nil {
-		return *x.Label
-	}
-	return FieldDescriptorProto_LABEL_OPTIONAL
-}
-
-func (x *FieldDescriptorProto) GetType() FieldDescriptorProto_Type {
-	if x != nil && x.Type != nil {
-		return *x.Type
-	}
-	return FieldDescriptorProto_TYPE_DOUBLE
-}
-
-func (x *FieldDescriptorProto) GetTypeName() string {
-	if x != nil && x.TypeName != nil {
-		return *x.TypeName
-	}
-	return ""
-}
-
-func (x *FieldDescriptorProto) GetExtendee() string {
-	if x != nil && x.Extendee != nil {
-		return *x.Extendee
-	}
-	return ""
-}
-
-func (x *FieldDescriptorProto) GetDefaultValue() string {
-	if x != nil && x.DefaultValue != nil {
-		return *x.DefaultValue
-	}
-	return ""
-}
-
-func (x *FieldDescriptorProto) GetOneofIndex() int32 {
-	if x != nil && x.OneofIndex != nil {
-		return *x.OneofIndex
-	}
-	return 0
-}
-
-func (x *FieldDescriptorProto) GetJsonName() string {
-	if x != nil && x.JsonName != nil {
-		return *x.JsonName
-	}
-	return ""
-}
-
-func (x *FieldDescriptorProto) GetOptions() *FieldOptions {
-	if x != nil {
-		return x.Options
-	}
-	return nil
-}
-
-func (x *FieldDescriptorProto) GetProto3Optional() bool {
-	if x != nil && x.Proto3Optional != nil {
-		return *x.Proto3Optional
-	}
-	return false
-}
-
-// Describes a oneof.
-type OneofDescriptorProto struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Name    *string       `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
-}
-
-func (x *OneofDescriptorProto) Reset() {
-	*x = OneofDescriptorProto{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *OneofDescriptorProto) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*OneofDescriptorProto) ProtoMessage() {}
-
-func (x *OneofDescriptorProto) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[5]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use OneofDescriptorProto.ProtoReflect.Descriptor instead.
-func (*OneofDescriptorProto) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{5}
-}
-
-func (x *OneofDescriptorProto) GetName() string {
-	if x != nil && x.Name != nil {
-		return *x.Name
-	}
-	return ""
-}
-
-func (x *OneofDescriptorProto) GetOptions() *OneofOptions {
-	if x != nil {
-		return x.Options
-	}
-	return nil
-}
-
-// Describes an enum type.
-type EnumDescriptorProto struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Name    *string                     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Value   []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
-	Options *EnumOptions                `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-	// Range of reserved numeric values. Reserved numeric values may not be used
-	// by enum values in the same enum declaration. Reserved ranges may not
-	// overlap.
-	ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
-	// Reserved enum value names, which may not be reused. A given name may only
-	// be reserved once.
-	ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
-}
-
-func (x *EnumDescriptorProto) Reset() {
-	*x = EnumDescriptorProto{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *EnumDescriptorProto) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EnumDescriptorProto) ProtoMessage() {}
-
-func (x *EnumDescriptorProto) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[6]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use EnumDescriptorProto.ProtoReflect.Descriptor instead.
-func (*EnumDescriptorProto) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{6}
-}
-
-func (x *EnumDescriptorProto) GetName() string {
-	if x != nil && x.Name != nil {
-		return *x.Name
-	}
-	return ""
-}
-
-func (x *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto {
-	if x != nil {
-		return x.Value
-	}
-	return nil
-}
-
-func (x *EnumDescriptorProto) GetOptions() *EnumOptions {
-	if x != nil {
-		return x.Options
-	}
-	return nil
-}
-
-func (x *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange {
-	if x != nil {
-		return x.ReservedRange
-	}
-	return nil
-}
-
-func (x *EnumDescriptorProto) GetReservedName() []string {
-	if x != nil {
-		return x.ReservedName
-	}
-	return nil
-}
-
-// Describes a value within an enum.
-type EnumValueDescriptorProto struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Name    *string           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Number  *int32            `protobuf:"varint,2,opt,name=number" json:"number,omitempty"`
-	Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-}
-
-func (x *EnumValueDescriptorProto) Reset() {
-	*x = EnumValueDescriptorProto{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *EnumValueDescriptorProto) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EnumValueDescriptorProto) ProtoMessage() {}
-
-func (x *EnumValueDescriptorProto) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[7]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use EnumValueDescriptorProto.ProtoReflect.Descriptor instead.
-func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{7}
-}
-
-func (x *EnumValueDescriptorProto) GetName() string {
-	if x != nil && x.Name != nil {
-		return *x.Name
-	}
-	return ""
-}
-
-func (x *EnumValueDescriptorProto) GetNumber() int32 {
-	if x != nil && x.Number != nil {
-		return *x.Number
-	}
-	return 0
-}
-
-func (x *EnumValueDescriptorProto) GetOptions() *EnumValueOptions {
-	if x != nil {
-		return x.Options
-	}
-	return nil
-}
-
-// Describes a service.
-type ServiceDescriptorProto struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Name    *string                  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	Method  []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"`
-	Options *ServiceOptions          `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-}
-
-func (x *ServiceDescriptorProto) Reset() {
-	*x = ServiceDescriptorProto{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ServiceDescriptorProto) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ServiceDescriptorProto) ProtoMessage() {}
-
-func (x *ServiceDescriptorProto) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[8]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ServiceDescriptorProto.ProtoReflect.Descriptor instead.
-func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{8}
-}
-
-func (x *ServiceDescriptorProto) GetName() string {
-	if x != nil && x.Name != nil {
-		return *x.Name
-	}
-	return ""
-}
-
-func (x *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto {
-	if x != nil {
-		return x.Method
-	}
-	return nil
-}
-
-func (x *ServiceDescriptorProto) GetOptions() *ServiceOptions {
-	if x != nil {
-		return x.Options
-	}
-	return nil
-}
-
-// Describes a method of a service.
-type MethodDescriptorProto struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	// Input and output type names.  These are resolved in the same way as
-	// FieldDescriptorProto.type_name, but must refer to a message type.
-	InputType  *string        `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"`
-	OutputType *string        `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"`
-	Options    *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"`
-	// Identifies if client streams multiple client messages
-	ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"`
-	// Identifies if server streams multiple server messages
-	ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"`
-}
-
-// Default values for MethodDescriptorProto fields.
-const (
-	Default_MethodDescriptorProto_ClientStreaming = bool(false)
-	Default_MethodDescriptorProto_ServerStreaming = bool(false)
-)
-
-func (x *MethodDescriptorProto) Reset() {
-	*x = MethodDescriptorProto{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *MethodDescriptorProto) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MethodDescriptorProto) ProtoMessage() {}
-
-func (x *MethodDescriptorProto) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[9]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use MethodDescriptorProto.ProtoReflect.Descriptor instead.
-func (*MethodDescriptorProto) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{9}
-}
-
-func (x *MethodDescriptorProto) GetName() string {
-	if x != nil && x.Name != nil {
-		return *x.Name
-	}
-	return ""
-}
-
-func (x *MethodDescriptorProto) GetInputType() string {
-	if x != nil && x.InputType != nil {
-		return *x.InputType
-	}
-	return ""
-}
-
-func (x *MethodDescriptorProto) GetOutputType() string {
-	if x != nil && x.OutputType != nil {
-		return *x.OutputType
-	}
-	return ""
-}
-
-func (x *MethodDescriptorProto) GetOptions() *MethodOptions {
-	if x != nil {
-		return x.Options
-	}
-	return nil
-}
-
-func (x *MethodDescriptorProto) GetClientStreaming() bool {
-	if x != nil && x.ClientStreaming != nil {
-		return *x.ClientStreaming
-	}
-	return Default_MethodDescriptorProto_ClientStreaming
-}
-
-func (x *MethodDescriptorProto) GetServerStreaming() bool {
-	if x != nil && x.ServerStreaming != nil {
-		return *x.ServerStreaming
-	}
-	return Default_MethodDescriptorProto_ServerStreaming
-}
-
-type FileOptions struct {
-	state           protoimpl.MessageState
-	sizeCache       protoimpl.SizeCache
-	unknownFields   protoimpl.UnknownFields
-	extensionFields protoimpl.ExtensionFields
-
-	// Sets the Java package where classes generated from this .proto will be
-	// placed.  By default, the proto package is used, but this is often
-	// inappropriate because proto packages do not normally start with backwards
-	// domain names.
-	JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"`
-	// If set, all the classes from the .proto file are wrapped in a single
-	// outer class with the given name.  This applies to both Proto1
-	// (equivalent to the old "--one_java_file" option) and Proto2 (where
-	// a .proto always translates to a single class, but you may want to
-	// explicitly choose the class name).
-	JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"`
-	// If set true, then the Java code generator will generate a separate .java
-	// file for each top-level message, enum, and service defined in the .proto
-	// file.  Thus, these types will *not* be nested inside the outer class
-	// named by java_outer_classname.  However, the outer class will still be
-	// generated to contain the file's getDescriptor() method as well as any
-	// top-level extensions defined in the file.
-	JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"`
-	// This option does nothing.
-	//
-	// Deprecated: Do not use.
-	JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"`
-	// If set true, then the Java2 code generator will generate code that
-	// throws an exception whenever an attempt is made to assign a non-UTF-8
-	// byte sequence to a string field.
-	// Message reflection will do the same.
-	// However, an extension field still accepts non-UTF-8 byte sequences.
-	// This option has no effect on when used with the lite runtime.
-	JavaStringCheckUtf8 *bool                     `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"`
-	OptimizeFor         *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"`
-	// Sets the Go package where structs generated from this .proto will be
-	// placed. If omitted, the Go package will be derived from the following:
-	//   - The basename of the package import path, if provided.
-	//   - Otherwise, the package statement in the .proto file, if present.
-	//   - Otherwise, the basename of the .proto file, without extension.
-	GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"`
-	// Should generic services be generated in each language?  "Generic" services
-	// are not specific to any particular RPC system.  They are generated by the
-	// main code generators in each language (without additional plugins).
-	// Generic services were the only kind of service generation supported by
-	// early versions of google.protobuf.
-	//
-	// Generic services are now considered deprecated in favor of using plugins
-	// that generate code specific to your particular RPC system.  Therefore,
-	// these default to false.  Old code which depends on generic services should
-	// explicitly set them to true.
-	CcGenericServices   *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
-	JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
-	PyGenericServices   *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
-	PhpGenericServices  *bool `protobuf:"varint,42,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"`
-	// Is this file deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for everything in the file, or it will be completely ignored; in the very
-	// least, this is a formalization for deprecating files.
-	Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// Enables the use of arenas for the proto messages in this file. This applies
-	// only to generated classes for C++.
-	CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=1" json:"cc_enable_arenas,omitempty"`
-	// Sets the objective c class prefix which is prepended to all objective c
-	// generated classes from this .proto. There is no default.
-	ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"`
-	// Namespace for generated classes; defaults to the package.
-	CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"`
-	// By default Swift generators will take the proto package and CamelCase it
-	// replacing '.' with underscore and use that to prefix the types/symbols
-	// defined. When this options is provided, they will use this value instead
-	// to prefix the types/symbols defined.
-	SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
-	// Sets the php class prefix which is prepended to all php generated classes
-	// from this .proto. Default is empty.
-	PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
-	// Use this option to change the namespace of php generated classes. Default
-	// is empty. When this option is empty, the package name will be used for
-	// determining the namespace.
-	PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
-	// Use this option to change the namespace of php generated metadata classes.
-	// Default is empty. When this option is empty, the proto file name will be
-	// used for determining the namespace.
-	PhpMetadataNamespace *string `protobuf:"bytes,44,opt,name=php_metadata_namespace,json=phpMetadataNamespace" json:"php_metadata_namespace,omitempty"`
-	// Use this option to change the package of ruby generated classes. Default
-	// is empty. When this option is not set, the package name will be used for
-	// determining the ruby package.
-	RubyPackage *string `protobuf:"bytes,45,opt,name=ruby_package,json=rubyPackage" json:"ruby_package,omitempty"`
-	// The parser stores options it doesn't recognize here.
-	// See the documentation for the "Options" section above.
-	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for FileOptions fields.
-const (
-	Default_FileOptions_JavaMultipleFiles   = bool(false)
-	Default_FileOptions_JavaStringCheckUtf8 = bool(false)
-	Default_FileOptions_OptimizeFor         = FileOptions_SPEED
-	Default_FileOptions_CcGenericServices   = bool(false)
-	Default_FileOptions_JavaGenericServices = bool(false)
-	Default_FileOptions_PyGenericServices   = bool(false)
-	Default_FileOptions_PhpGenericServices  = bool(false)
-	Default_FileOptions_Deprecated          = bool(false)
-	Default_FileOptions_CcEnableArenas      = bool(true)
-)
-
-func (x *FileOptions) Reset() {
-	*x = FileOptions{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *FileOptions) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FileOptions) ProtoMessage() {}
-
-func (x *FileOptions) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[10]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use FileOptions.ProtoReflect.Descriptor instead.
-func (*FileOptions) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{10}
-}
-
-var extRange_FileOptions = []protoiface.ExtensionRangeV1{
-	{Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use FileOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*FileOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
-	return extRange_FileOptions
-}
-
-func (x *FileOptions) GetJavaPackage() string {
-	if x != nil && x.JavaPackage != nil {
-		return *x.JavaPackage
-	}
-	return ""
-}
-
-func (x *FileOptions) GetJavaOuterClassname() string {
-	if x != nil && x.JavaOuterClassname != nil {
-		return *x.JavaOuterClassname
-	}
-	return ""
-}
-
-func (x *FileOptions) GetJavaMultipleFiles() bool {
-	if x != nil && x.JavaMultipleFiles != nil {
-		return *x.JavaMultipleFiles
-	}
-	return Default_FileOptions_JavaMultipleFiles
-}
-
-// Deprecated: Do not use.
-func (x *FileOptions) GetJavaGenerateEqualsAndHash() bool {
-	if x != nil && x.JavaGenerateEqualsAndHash != nil {
-		return *x.JavaGenerateEqualsAndHash
-	}
-	return false
-}
-
-func (x *FileOptions) GetJavaStringCheckUtf8() bool {
-	if x != nil && x.JavaStringCheckUtf8 != nil {
-		return *x.JavaStringCheckUtf8
-	}
-	return Default_FileOptions_JavaStringCheckUtf8
-}
-
-func (x *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode {
-	if x != nil && x.OptimizeFor != nil {
-		return *x.OptimizeFor
-	}
-	return Default_FileOptions_OptimizeFor
-}
-
-func (x *FileOptions) GetGoPackage() string {
-	if x != nil && x.GoPackage != nil {
-		return *x.GoPackage
-	}
-	return ""
-}
-
-func (x *FileOptions) GetCcGenericServices() bool {
-	if x != nil && x.CcGenericServices != nil {
-		return *x.CcGenericServices
-	}
-	return Default_FileOptions_CcGenericServices
-}
-
-func (x *FileOptions) GetJavaGenericServices() bool {
-	if x != nil && x.JavaGenericServices != nil {
-		return *x.JavaGenericServices
-	}
-	return Default_FileOptions_JavaGenericServices
-}
-
-func (x *FileOptions) GetPyGenericServices() bool {
-	if x != nil && x.PyGenericServices != nil {
-		return *x.PyGenericServices
-	}
-	return Default_FileOptions_PyGenericServices
-}
-
-func (x *FileOptions) GetPhpGenericServices() bool {
-	if x != nil && x.PhpGenericServices != nil {
-		return *x.PhpGenericServices
-	}
-	return Default_FileOptions_PhpGenericServices
-}
-
-func (x *FileOptions) GetDeprecated() bool {
-	if x != nil && x.Deprecated != nil {
-		return *x.Deprecated
-	}
-	return Default_FileOptions_Deprecated
-}
-
-func (x *FileOptions) GetCcEnableArenas() bool {
-	if x != nil && x.CcEnableArenas != nil {
-		return *x.CcEnableArenas
-	}
-	return Default_FileOptions_CcEnableArenas
-}
-
-func (x *FileOptions) GetObjcClassPrefix() string {
-	if x != nil && x.ObjcClassPrefix != nil {
-		return *x.ObjcClassPrefix
-	}
-	return ""
-}
-
-func (x *FileOptions) GetCsharpNamespace() string {
-	if x != nil && x.CsharpNamespace != nil {
-		return *x.CsharpNamespace
-	}
-	return ""
-}
-
-func (x *FileOptions) GetSwiftPrefix() string {
-	if x != nil && x.SwiftPrefix != nil {
-		return *x.SwiftPrefix
-	}
-	return ""
-}
-
-func (x *FileOptions) GetPhpClassPrefix() string {
-	if x != nil && x.PhpClassPrefix != nil {
-		return *x.PhpClassPrefix
-	}
-	return ""
-}
-
-func (x *FileOptions) GetPhpNamespace() string {
-	if x != nil && x.PhpNamespace != nil {
-		return *x.PhpNamespace
-	}
-	return ""
-}
-
-func (x *FileOptions) GetPhpMetadataNamespace() string {
-	if x != nil && x.PhpMetadataNamespace != nil {
-		return *x.PhpMetadataNamespace
-	}
-	return ""
-}
-
-func (x *FileOptions) GetRubyPackage() string {
-	if x != nil && x.RubyPackage != nil {
-		return *x.RubyPackage
-	}
-	return ""
-}
-
-func (x *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if x != nil {
-		return x.UninterpretedOption
-	}
-	return nil
-}
-
-type MessageOptions struct {
-	state           protoimpl.MessageState
-	sizeCache       protoimpl.SizeCache
-	unknownFields   protoimpl.UnknownFields
-	extensionFields protoimpl.ExtensionFields
-
-	// Set true to use the old proto1 MessageSet wire format for extensions.
-	// This is provided for backwards-compatibility with the MessageSet wire
-	// format.  You should not use this for any other reason:  It's less
-	// efficient, has fewer features, and is more complicated.
-	//
-	// The message must be defined exactly as follows:
-	//   message Foo {
-	//     option message_set_wire_format = true;
-	//     extensions 4 to max;
-	//   }
-	// Note that the message cannot have any defined fields; MessageSets only
-	// have extensions.
-	//
-	// All extensions of your type must be singular messages; e.g. they cannot
-	// be int32s, enums, or repeated messages.
-	//
-	// Because this is an option, the above two restrictions are not enforced by
-	// the protocol compiler.
-	MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"`
-	// Disables the generation of the standard "descriptor()" accessor, which can
-	// conflict with a field of the same name.  This is meant to make migration
-	// from proto1 easier; new code should avoid fields named "descriptor".
-	NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"`
-	// Is this message deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the message, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating messages.
-	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// Whether the message is an automatically generated map entry type for the
-	// maps field.
-	//
-	// For maps fields:
-	//     map<KeyType, ValueType> map_field = 1;
-	// The parsed descriptor looks like:
-	//     message MapFieldEntry {
-	//         option map_entry = true;
-	//         optional KeyType key = 1;
-	//         optional ValueType value = 2;
-	//     }
-	//     repeated MapFieldEntry map_field = 1;
-	//
-	// Implementations may choose not to generate the map_entry=true message, but
-	// use a native map in the target language to hold the keys and values.
-	// The reflection APIs in such implementations still need to work as
-	// if the field is a repeated message field.
-	//
-	// NOTE: Do not set the option in .proto files. Always use the maps syntax
-	// instead. The option should only be implicitly set by the proto compiler
-	// parser.
-	MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for MessageOptions fields.
-const (
-	Default_MessageOptions_MessageSetWireFormat         = bool(false)
-	Default_MessageOptions_NoStandardDescriptorAccessor = bool(false)
-	Default_MessageOptions_Deprecated                   = bool(false)
-)
-
-func (x *MessageOptions) Reset() {
-	*x = MessageOptions{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *MessageOptions) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MessageOptions) ProtoMessage() {}
-
-func (x *MessageOptions) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[11]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use MessageOptions.ProtoReflect.Descriptor instead.
-func (*MessageOptions) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{11}
-}
-
-var extRange_MessageOptions = []protoiface.ExtensionRangeV1{
-	{Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use MessageOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*MessageOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
-	return extRange_MessageOptions
-}
-
-func (x *MessageOptions) GetMessageSetWireFormat() bool {
-	if x != nil && x.MessageSetWireFormat != nil {
-		return *x.MessageSetWireFormat
-	}
-	return Default_MessageOptions_MessageSetWireFormat
-}
-
-func (x *MessageOptions) GetNoStandardDescriptorAccessor() bool {
-	if x != nil && x.NoStandardDescriptorAccessor != nil {
-		return *x.NoStandardDescriptorAccessor
-	}
-	return Default_MessageOptions_NoStandardDescriptorAccessor
-}
-
-func (x *MessageOptions) GetDeprecated() bool {
-	if x != nil && x.Deprecated != nil {
-		return *x.Deprecated
-	}
-	return Default_MessageOptions_Deprecated
-}
-
-func (x *MessageOptions) GetMapEntry() bool {
-	if x != nil && x.MapEntry != nil {
-		return *x.MapEntry
-	}
-	return false
-}
-
-func (x *MessageOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if x != nil {
-		return x.UninterpretedOption
-	}
-	return nil
-}
-
-type FieldOptions struct {
-	state           protoimpl.MessageState
-	sizeCache       protoimpl.SizeCache
-	unknownFields   protoimpl.UnknownFields
-	extensionFields protoimpl.ExtensionFields
-
-	// The ctype option instructs the C++ code generator to use a different
-	// representation of the field than it normally would.  See the specific
-	// options below.  This option is not yet implemented in the open source
-	// release -- sorry, we'll try to include it in a future version!
-	Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"`
-	// The packed option can be enabled for repeated primitive fields to enable
-	// a more efficient representation on the wire. Rather than repeatedly
-	// writing the tag and type for each element, the entire array is encoded as
-	// a single length-delimited blob. In proto3, only explicit setting it to
-	// false will avoid using packed encoding.
-	Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
-	// The jstype option determines the JavaScript type used for values of the
-	// field.  The option is permitted only for 64 bit integral and fixed types
-	// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
-	// is represented as JavaScript string, which avoids loss of precision that
-	// can happen when a large value is converted to a floating point JavaScript.
-	// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
-	// use the JavaScript "number" type.  The behavior of the default option
-	// JS_NORMAL is implementation dependent.
-	//
-	// This option is an enum to permit additional types to be added, e.g.
-	// goog.math.Integer.
-	Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
-	// Should this field be parsed lazily?  Lazy applies only to message-type
-	// fields.  It means that when the outer message is initially parsed, the
-	// inner message's contents will not be parsed but instead stored in encoded
-	// form.  The inner message will actually be parsed when it is first accessed.
-	//
-	// This is only a hint.  Implementations are free to choose whether to use
-	// eager or lazy parsing regardless of the value of this option.  However,
-	// setting this option true suggests that the protocol author believes that
-	// using lazy parsing on this field is worth the additional bookkeeping
-	// overhead typically needed to implement it.
-	//
-	// This option does not affect the public interface of any generated code;
-	// all method signatures remain the same.  Furthermore, thread-safety of the
-	// interface is not affected by this option; const methods remain safe to
-	// call from multiple threads concurrently, while non-const methods continue
-	// to require exclusive access.
-	//
-	//
-	// Note that implementations may choose not to check required fields within
-	// a lazy sub-message.  That is, calling IsInitialized() on the outer message
-	// may return true even if the inner message has missing required fields.
-	// This is necessary because otherwise the inner message would have to be
-	// parsed in order to perform the check, defeating the purpose of lazy
-	// parsing.  An implementation which chooses not to check required fields
-	// must be consistent about it.  That is, for any particular sub-message, the
-	// implementation must either *always* check its required fields, or *never*
-	// check its required fields, regardless of whether or not the message has
-	// been parsed.
-	Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"`
-	// Is this field deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for accessors, or it will be completely ignored; in the very least, this
-	// is a formalization for deprecating fields.
-	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// For Google-internal migration only. Do not use.
-	Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for FieldOptions fields.
-const (
-	Default_FieldOptions_Ctype      = FieldOptions_STRING
-	Default_FieldOptions_Jstype     = FieldOptions_JS_NORMAL
-	Default_FieldOptions_Lazy       = bool(false)
-	Default_FieldOptions_Deprecated = bool(false)
-	Default_FieldOptions_Weak       = bool(false)
-)
-
-func (x *FieldOptions) Reset() {
-	*x = FieldOptions{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *FieldOptions) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FieldOptions) ProtoMessage() {}
-
-func (x *FieldOptions) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[12]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use FieldOptions.ProtoReflect.Descriptor instead.
-func (*FieldOptions) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12}
-}
-
-var extRange_FieldOptions = []protoiface.ExtensionRangeV1{
-	{Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use FieldOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*FieldOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
-	return extRange_FieldOptions
-}
-
-func (x *FieldOptions) GetCtype() FieldOptions_CType {
-	if x != nil && x.Ctype != nil {
-		return *x.Ctype
-	}
-	return Default_FieldOptions_Ctype
-}
-
-func (x *FieldOptions) GetPacked() bool {
-	if x != nil && x.Packed != nil {
-		return *x.Packed
-	}
-	return false
-}
-
-func (x *FieldOptions) GetJstype() FieldOptions_JSType {
-	if x != nil && x.Jstype != nil {
-		return *x.Jstype
-	}
-	return Default_FieldOptions_Jstype
-}
-
-func (x *FieldOptions) GetLazy() bool {
-	if x != nil && x.Lazy != nil {
-		return *x.Lazy
-	}
-	return Default_FieldOptions_Lazy
-}
-
-func (x *FieldOptions) GetDeprecated() bool {
-	if x != nil && x.Deprecated != nil {
-		return *x.Deprecated
-	}
-	return Default_FieldOptions_Deprecated
-}
-
-func (x *FieldOptions) GetWeak() bool {
-	if x != nil && x.Weak != nil {
-		return *x.Weak
-	}
-	return Default_FieldOptions_Weak
-}
-
-func (x *FieldOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if x != nil {
-		return x.UninterpretedOption
-	}
-	return nil
-}
-
-type OneofOptions struct {
-	state           protoimpl.MessageState
-	sizeCache       protoimpl.SizeCache
-	unknownFields   protoimpl.UnknownFields
-	extensionFields protoimpl.ExtensionFields
-
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-func (x *OneofOptions) Reset() {
-	*x = OneofOptions{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *OneofOptions) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*OneofOptions) ProtoMessage() {}
-
-func (x *OneofOptions) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[13]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use OneofOptions.ProtoReflect.Descriptor instead.
-func (*OneofOptions) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{13}
-}
-
-var extRange_OneofOptions = []protoiface.ExtensionRangeV1{
-	{Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use OneofOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*OneofOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
-	return extRange_OneofOptions
-}
-
-func (x *OneofOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if x != nil {
-		return x.UninterpretedOption
-	}
-	return nil
-}
-
-type EnumOptions struct {
-	state           protoimpl.MessageState
-	sizeCache       protoimpl.SizeCache
-	unknownFields   protoimpl.UnknownFields
-	extensionFields protoimpl.ExtensionFields
-
-	// Set this option to true to allow mapping different tag names to the same
-	// value.
-	AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"`
-	// Is this enum deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the enum, or it will be completely ignored; in the very least, this
-	// is a formalization for deprecating enums.
-	Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for EnumOptions fields.
-const (
-	Default_EnumOptions_Deprecated = bool(false)
-)
-
-func (x *EnumOptions) Reset() {
-	*x = EnumOptions{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *EnumOptions) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EnumOptions) ProtoMessage() {}
-
-func (x *EnumOptions) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[14]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use EnumOptions.ProtoReflect.Descriptor instead.
-func (*EnumOptions) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{14}
-}
-
-var extRange_EnumOptions = []protoiface.ExtensionRangeV1{
-	{Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use EnumOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*EnumOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
-	return extRange_EnumOptions
-}
-
-func (x *EnumOptions) GetAllowAlias() bool {
-	if x != nil && x.AllowAlias != nil {
-		return *x.AllowAlias
-	}
-	return false
-}
-
-func (x *EnumOptions) GetDeprecated() bool {
-	if x != nil && x.Deprecated != nil {
-		return *x.Deprecated
-	}
-	return Default_EnumOptions_Deprecated
-}
-
-func (x *EnumOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if x != nil {
-		return x.UninterpretedOption
-	}
-	return nil
-}
-
-type EnumValueOptions struct {
-	state           protoimpl.MessageState
-	sizeCache       protoimpl.SizeCache
-	unknownFields   protoimpl.UnknownFields
-	extensionFields protoimpl.ExtensionFields
-
-	// Is this enum value deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the enum value, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating enum values.
-	Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for EnumValueOptions fields.
-const (
-	Default_EnumValueOptions_Deprecated = bool(false)
-)
-
-func (x *EnumValueOptions) Reset() {
-	*x = EnumValueOptions{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *EnumValueOptions) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EnumValueOptions) ProtoMessage() {}
-
-func (x *EnumValueOptions) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[15]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use EnumValueOptions.ProtoReflect.Descriptor instead.
-func (*EnumValueOptions) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{15}
-}
-
-var extRange_EnumValueOptions = []protoiface.ExtensionRangeV1{
-	{Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use EnumValueOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*EnumValueOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
-	return extRange_EnumValueOptions
-}
-
-func (x *EnumValueOptions) GetDeprecated() bool {
-	if x != nil && x.Deprecated != nil {
-		return *x.Deprecated
-	}
-	return Default_EnumValueOptions_Deprecated
-}
-
-func (x *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if x != nil {
-		return x.UninterpretedOption
-	}
-	return nil
-}
-
-type ServiceOptions struct {
-	state           protoimpl.MessageState
-	sizeCache       protoimpl.SizeCache
-	unknownFields   protoimpl.UnknownFields
-	extensionFields protoimpl.ExtensionFields
-
-	// Is this service deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the service, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating services.
-	Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for ServiceOptions fields.
-const (
-	Default_ServiceOptions_Deprecated = bool(false)
-)
-
-func (x *ServiceOptions) Reset() {
-	*x = ServiceOptions{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ServiceOptions) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ServiceOptions) ProtoMessage() {}
-
-func (x *ServiceOptions) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[16]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ServiceOptions.ProtoReflect.Descriptor instead.
-func (*ServiceOptions) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{16}
-}
-
-var extRange_ServiceOptions = []protoiface.ExtensionRangeV1{
-	{Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use ServiceOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*ServiceOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
-	return extRange_ServiceOptions
-}
-
-func (x *ServiceOptions) GetDeprecated() bool {
-	if x != nil && x.Deprecated != nil {
-		return *x.Deprecated
-	}
-	return Default_ServiceOptions_Deprecated
-}
-
-func (x *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if x != nil {
-		return x.UninterpretedOption
-	}
-	return nil
-}
-
-type MethodOptions struct {
-	state           protoimpl.MessageState
-	sizeCache       protoimpl.SizeCache
-	unknownFields   protoimpl.UnknownFields
-	extensionFields protoimpl.ExtensionFields
-
-	// Is this method deprecated?
-	// Depending on the target platform, this can emit Deprecated annotations
-	// for the method, or it will be completely ignored; in the very least,
-	// this is a formalization for deprecating methods.
-	Deprecated       *bool                           `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
-	IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"`
-	// The parser stores options it doesn't recognize here. See above.
-	UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
-}
-
-// Default values for MethodOptions fields.
-const (
-	Default_MethodOptions_Deprecated       = bool(false)
-	Default_MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN
-)
-
-func (x *MethodOptions) Reset() {
-	*x = MethodOptions{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *MethodOptions) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MethodOptions) ProtoMessage() {}
-
-func (x *MethodOptions) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[17]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use MethodOptions.ProtoReflect.Descriptor instead.
-func (*MethodOptions) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{17}
-}
-
-var extRange_MethodOptions = []protoiface.ExtensionRangeV1{
-	{Start: 1000, End: 536870911},
-}
-
-// Deprecated: Use MethodOptions.ProtoReflect.Descriptor.ExtensionRanges instead.
-func (*MethodOptions) ExtensionRangeArray() []protoiface.ExtensionRangeV1 {
-	return extRange_MethodOptions
-}
-
-func (x *MethodOptions) GetDeprecated() bool {
-	if x != nil && x.Deprecated != nil {
-		return *x.Deprecated
-	}
-	return Default_MethodOptions_Deprecated
-}
-
-func (x *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel {
-	if x != nil && x.IdempotencyLevel != nil {
-		return *x.IdempotencyLevel
-	}
-	return Default_MethodOptions_IdempotencyLevel
-}
-
-func (x *MethodOptions) GetUninterpretedOption() []*UninterpretedOption {
-	if x != nil {
-		return x.UninterpretedOption
-	}
-	return nil
-}
-
-// A message representing a option the parser does not recognize. This only
-// appears in options protos created by the compiler::Parser class.
-// DescriptorPool resolves these when building Descriptor objects. Therefore,
-// options protos in descriptor objects (e.g. returned by Descriptor::options(),
-// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
-// in them.
-type UninterpretedOption struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"`
-	// The value of the uninterpreted option, in whatever type the tokenizer
-	// identified it as during parsing. Exactly one of these should be set.
-	IdentifierValue  *string  `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"`
-	PositiveIntValue *uint64  `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"`
-	NegativeIntValue *int64   `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"`
-	DoubleValue      *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
-	StringValue      []byte   `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
-	AggregateValue   *string  `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"`
-}
-
-func (x *UninterpretedOption) Reset() {
-	*x = UninterpretedOption{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *UninterpretedOption) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*UninterpretedOption) ProtoMessage() {}
-
-func (x *UninterpretedOption) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[18]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use UninterpretedOption.ProtoReflect.Descriptor instead.
-func (*UninterpretedOption) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{18}
-}
-
-func (x *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
-	if x != nil {
-		return x.Name
-	}
-	return nil
-}
-
-func (x *UninterpretedOption) GetIdentifierValue() string {
-	if x != nil && x.IdentifierValue != nil {
-		return *x.IdentifierValue
-	}
-	return ""
-}
-
-func (x *UninterpretedOption) GetPositiveIntValue() uint64 {
-	if x != nil && x.PositiveIntValue != nil {
-		return *x.PositiveIntValue
-	}
-	return 0
-}
-
-func (x *UninterpretedOption) GetNegativeIntValue() int64 {
-	if x != nil && x.NegativeIntValue != nil {
-		return *x.NegativeIntValue
-	}
-	return 0
-}
-
-func (x *UninterpretedOption) GetDoubleValue() float64 {
-	if x != nil && x.DoubleValue != nil {
-		return *x.DoubleValue
-	}
-	return 0
-}
-
-func (x *UninterpretedOption) GetStringValue() []byte {
-	if x != nil {
-		return x.StringValue
-	}
-	return nil
-}
-
-func (x *UninterpretedOption) GetAggregateValue() string {
-	if x != nil && x.AggregateValue != nil {
-		return *x.AggregateValue
-	}
-	return ""
-}
-
-// Encapsulates information about the original source file from which a
-// FileDescriptorProto was generated.
-type SourceCodeInfo struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// A Location identifies a piece of source code in a .proto file which
-	// corresponds to a particular definition.  This information is intended
-	// to be useful to IDEs, code indexers, documentation generators, and similar
-	// tools.
-	//
-	// For example, say we have a file like:
-	//   message Foo {
-	//     optional string foo = 1;
-	//   }
-	// Let's look at just the field definition:
-	//   optional string foo = 1;
-	//   ^       ^^     ^^  ^  ^^^
-	//   a       bc     de  f  ghi
-	// We have the following locations:
-	//   span   path               represents
-	//   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
-	//   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
-	//   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
-	//   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
-	//   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
-	//
-	// Notes:
-	// - A location may refer to a repeated field itself (i.e. not to any
-	//   particular index within it).  This is used whenever a set of elements are
-	//   logically enclosed in a single code segment.  For example, an entire
-	//   extend block (possibly containing multiple extension definitions) will
-	//   have an outer location whose path refers to the "extensions" repeated
-	//   field without an index.
-	// - Multiple locations may have the same path.  This happens when a single
-	//   logical declaration is spread out across multiple places.  The most
-	//   obvious example is the "extend" block again -- there may be multiple
-	//   extend blocks in the same scope, each of which will have the same path.
-	// - A location's span is not always a subset of its parent's span.  For
-	//   example, the "extendee" of an extension declaration appears at the
-	//   beginning of the "extend" block and is shared by all extensions within
-	//   the block.
-	// - Just because a location's span is a subset of some other location's span
-	//   does not mean that it is a descendant.  For example, a "group" defines
-	//   both a type and a field in a single declaration.  Thus, the locations
-	//   corresponding to the type and field and their components will overlap.
-	// - Code which tries to interpret locations should probably be designed to
-	//   ignore those that it doesn't understand, as more types of locations could
-	//   be recorded in the future.
-	Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"`
-}
-
-func (x *SourceCodeInfo) Reset() {
-	*x = SourceCodeInfo{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *SourceCodeInfo) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SourceCodeInfo) ProtoMessage() {}
-
-func (x *SourceCodeInfo) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[19]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use SourceCodeInfo.ProtoReflect.Descriptor instead.
-func (*SourceCodeInfo) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19}
-}
-
-func (x *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
-	if x != nil {
-		return x.Location
-	}
-	return nil
-}
-
-// Describes the relationship between generated code and its original source
-// file. A GeneratedCodeInfo message is associated with only one generated
-// source file, but may contain references to different source .proto files.
-type GeneratedCodeInfo struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// An Annotation connects some span of text in generated code to an element
-	// of its generating .proto file.
-	Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"`
-}
-
-func (x *GeneratedCodeInfo) Reset() {
-	*x = GeneratedCodeInfo{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *GeneratedCodeInfo) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*GeneratedCodeInfo) ProtoMessage() {}
-
-func (x *GeneratedCodeInfo) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[20]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use GeneratedCodeInfo.ProtoReflect.Descriptor instead.
-func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{20}
-}
-
-func (x *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
-	if x != nil {
-		return x.Annotation
-	}
-	return nil
-}
-
-type DescriptorProto_ExtensionRange struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Start   *int32                 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
-	End     *int32                 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`     // Exclusive.
-	Options *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
-}
-
-func (x *DescriptorProto_ExtensionRange) Reset() {
-	*x = DescriptorProto_ExtensionRange{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DescriptorProto_ExtensionRange) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DescriptorProto_ExtensionRange) ProtoMessage() {}
-
-func (x *DescriptorProto_ExtensionRange) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[21]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DescriptorProto_ExtensionRange.ProtoReflect.Descriptor instead.
-func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2, 0}
-}
-
-func (x *DescriptorProto_ExtensionRange) GetStart() int32 {
-	if x != nil && x.Start != nil {
-		return *x.Start
-	}
-	return 0
-}
-
-func (x *DescriptorProto_ExtensionRange) GetEnd() int32 {
-	if x != nil && x.End != nil {
-		return *x.End
-	}
-	return 0
-}
-
-func (x *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
-	if x != nil {
-		return x.Options
-	}
-	return nil
-}
-
-// Range of reserved tag numbers. Reserved tag numbers may not be used by
-// fields or extension ranges in the same message. Reserved ranges may
-// not overlap.
-type DescriptorProto_ReservedRange struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
-	End   *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`     // Exclusive.
-}
-
-func (x *DescriptorProto_ReservedRange) Reset() {
-	*x = DescriptorProto_ReservedRange{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DescriptorProto_ReservedRange) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DescriptorProto_ReservedRange) ProtoMessage() {}
-
-func (x *DescriptorProto_ReservedRange) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[22]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DescriptorProto_ReservedRange.ProtoReflect.Descriptor instead.
-func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2, 1}
-}
-
-func (x *DescriptorProto_ReservedRange) GetStart() int32 {
-	if x != nil && x.Start != nil {
-		return *x.Start
-	}
-	return 0
-}
-
-func (x *DescriptorProto_ReservedRange) GetEnd() int32 {
-	if x != nil && x.End != nil {
-		return *x.End
-	}
-	return 0
-}
-
-// Range of reserved numeric values. Reserved values may not be used by
-// entries in the same enum. Reserved ranges may not overlap.
-//
-// Note that this is distinct from DescriptorProto.ReservedRange in that it
-// is inclusive such that it can appropriately represent the entire int32
-// domain.
-type EnumDescriptorProto_EnumReservedRange struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive.
-	End   *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`     // Inclusive.
-}
-
-func (x *EnumDescriptorProto_EnumReservedRange) Reset() {
-	*x = EnumDescriptorProto_EnumReservedRange{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *EnumDescriptorProto_EnumReservedRange) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {}
-
-func (x *EnumDescriptorProto_EnumReservedRange) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[23]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use EnumDescriptorProto_EnumReservedRange.ProtoReflect.Descriptor instead.
-func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{6, 0}
-}
-
-func (x *EnumDescriptorProto_EnumReservedRange) GetStart() int32 {
-	if x != nil && x.Start != nil {
-		return *x.Start
-	}
-	return 0
-}
-
-func (x *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 {
-	if x != nil && x.End != nil {
-		return *x.End
-	}
-	return 0
-}
-
-// The name of the uninterpreted option.  Each string represents a segment in
-// a dot-separated name.  is_extension is true iff a segment represents an
-// extension (denoted with parentheses in options specs in .proto files).
-// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
-// "foo.(bar.baz).qux".
-type UninterpretedOption_NamePart struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	NamePart    *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"`
-	IsExtension *bool   `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"`
-}
-
-func (x *UninterpretedOption_NamePart) Reset() {
-	*x = UninterpretedOption_NamePart{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *UninterpretedOption_NamePart) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*UninterpretedOption_NamePart) ProtoMessage() {}
-
-func (x *UninterpretedOption_NamePart) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[24]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use UninterpretedOption_NamePart.ProtoReflect.Descriptor instead.
-func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{18, 0}
-}
-
-func (x *UninterpretedOption_NamePart) GetNamePart() string {
-	if x != nil && x.NamePart != nil {
-		return *x.NamePart
-	}
-	return ""
-}
-
-func (x *UninterpretedOption_NamePart) GetIsExtension() bool {
-	if x != nil && x.IsExtension != nil {
-		return *x.IsExtension
-	}
-	return false
-}
-
-type SourceCodeInfo_Location struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// Identifies which part of the FileDescriptorProto was defined at this
-	// location.
-	//
-	// Each element is a field number or an index.  They form a path from
-	// the root FileDescriptorProto to the place where the definition.  For
-	// example, this path:
-	//   [ 4, 3, 2, 7, 1 ]
-	// refers to:
-	//   file.message_type(3)  // 4, 3
-	//       .field(7)         // 2, 7
-	//       .name()           // 1
-	// This is because FileDescriptorProto.message_type has field number 4:
-	//   repeated DescriptorProto message_type = 4;
-	// and DescriptorProto.field has field number 2:
-	//   repeated FieldDescriptorProto field = 2;
-	// and FieldDescriptorProto.name has field number 1:
-	//   optional string name = 1;
-	//
-	// Thus, the above path gives the location of a field name.  If we removed
-	// the last element:
-	//   [ 4, 3, 2, 7 ]
-	// this path refers to the whole field declaration (from the beginning
-	// of the label to the terminating semicolon).
-	Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
-	// Always has exactly three or four elements: start line, start column,
-	// end line (optional, otherwise assumed same as start line), end column.
-	// These are packed into a single field for efficiency.  Note that line
-	// and column numbers are zero-based -- typically you will want to add
-	// 1 to each before displaying to a user.
-	Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"`
-	// If this SourceCodeInfo represents a complete declaration, these are any
-	// comments appearing before and after the declaration which appear to be
-	// attached to the declaration.
-	//
-	// A series of line comments appearing on consecutive lines, with no other
-	// tokens appearing on those lines, will be treated as a single comment.
-	//
-	// leading_detached_comments will keep paragraphs of comments that appear
-	// before (but not connected to) the current element. Each paragraph,
-	// separated by empty lines, will be one comment element in the repeated
-	// field.
-	//
-	// Only the comment content is provided; comment markers (e.g. //) are
-	// stripped out.  For block comments, leading whitespace and an asterisk
-	// will be stripped from the beginning of each line other than the first.
-	// Newlines are included in the output.
-	//
-	// Examples:
-	//
-	//   optional int32 foo = 1;  // Comment attached to foo.
-	//   // Comment attached to bar.
-	//   optional int32 bar = 2;
-	//
-	//   optional string baz = 3;
-	//   // Comment attached to baz.
-	//   // Another line attached to baz.
-	//
-	//   // Comment attached to qux.
-	//   //
-	//   // Another line attached to qux.
-	//   optional double qux = 4;
-	//
-	//   // Detached comment for corge. This is not leading or trailing comments
-	//   // to qux or corge because there are blank lines separating it from
-	//   // both.
-	//
-	//   // Detached comment for corge paragraph 2.
-	//
-	//   optional string corge = 5;
-	//   /* Block comment attached
-	//    * to corge.  Leading asterisks
-	//    * will be removed. */
-	//   /* Block comment attached to
-	//    * grault. */
-	//   optional int32 grault = 6;
-	//
-	//   // ignored detached comments.
-	LeadingComments         *string  `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"`
-	TrailingComments        *string  `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"`
-	LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"`
-}
-
-func (x *SourceCodeInfo_Location) Reset() {
-	*x = SourceCodeInfo_Location{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *SourceCodeInfo_Location) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SourceCodeInfo_Location) ProtoMessage() {}
-
-func (x *SourceCodeInfo_Location) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[25]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use SourceCodeInfo_Location.ProtoReflect.Descriptor instead.
-func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 0}
-}
-
-func (x *SourceCodeInfo_Location) GetPath() []int32 {
-	if x != nil {
-		return x.Path
-	}
-	return nil
-}
-
-func (x *SourceCodeInfo_Location) GetSpan() []int32 {
-	if x != nil {
-		return x.Span
-	}
-	return nil
-}
-
-func (x *SourceCodeInfo_Location) GetLeadingComments() string {
-	if x != nil && x.LeadingComments != nil {
-		return *x.LeadingComments
-	}
-	return ""
-}
-
-func (x *SourceCodeInfo_Location) GetTrailingComments() string {
-	if x != nil && x.TrailingComments != nil {
-		return *x.TrailingComments
-	}
-	return ""
-}
-
-func (x *SourceCodeInfo_Location) GetLeadingDetachedComments() []string {
-	if x != nil {
-		return x.LeadingDetachedComments
-	}
-	return nil
-}
-
-type GeneratedCodeInfo_Annotation struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// Identifies the element in the original source .proto file. This field
-	// is formatted the same as SourceCodeInfo.Location.path.
-	Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
-	// Identifies the filesystem path to the original source .proto.
-	SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
-	// Identifies the starting offset in bytes in the generated code
-	// that relates to the identified object.
-	Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"`
-	// Identifies the ending offset in bytes in the generated code that
-	// relates to the identified offset. The end offset should be one past
-	// the last relevant byte (so the length of the text = end - begin).
-	End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"`
-}
-
-func (x *GeneratedCodeInfo_Annotation) Reset() {
-	*x = GeneratedCodeInfo_Annotation{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *GeneratedCodeInfo_Annotation) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*GeneratedCodeInfo_Annotation) ProtoMessage() {}
-
-func (x *GeneratedCodeInfo_Annotation) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_descriptor_proto_msgTypes[26]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use GeneratedCodeInfo_Annotation.ProtoReflect.Descriptor instead.
-func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{20, 0}
-}
-
-func (x *GeneratedCodeInfo_Annotation) GetPath() []int32 {
-	if x != nil {
-		return x.Path
-	}
-	return nil
-}
-
-func (x *GeneratedCodeInfo_Annotation) GetSourceFile() string {
-	if x != nil && x.SourceFile != nil {
-		return *x.SourceFile
-	}
-	return ""
-}
-
-func (x *GeneratedCodeInfo_Annotation) GetBegin() int32 {
-	if x != nil && x.Begin != nil {
-		return *x.Begin
-	}
-	return 0
-}
-
-func (x *GeneratedCodeInfo_Annotation) GetEnd() int32 {
-	if x != nil && x.End != nil {
-		return *x.End
-	}
-	return 0
-}
-
-var File_google_protobuf_descriptor_proto protoreflect.FileDescriptor
-
-var file_google_protobuf_descriptor_proto_rawDesc = []byte{
-	0x0a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x22, 0x4d, 0x0a, 0x11, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72,
-	0x69, 0x70, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65,
-	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73,
-	0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x04, 0x66, 0x69,
-	0x6c, 0x65, 0x22, 0xe4, 0x04, 0x0a, 0x13, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72,
-	0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61,
-	0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18,
-	0x0a, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x65,
-	0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65,
-	0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x75, 0x62, 0x6c,
-	0x69, 0x63, 0x5f, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0a, 0x20,
-	0x03, 0x28, 0x05, 0x52, 0x10, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x44, 0x65, 0x70, 0x65, 0x6e,
-	0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x77, 0x65, 0x61, 0x6b, 0x5f, 0x64, 0x65,
-	0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0e,
-	0x77, 0x65, 0x61, 0x6b, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x43,
-	0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f,
-	0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54,
-	0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65,
-	0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73,
-	0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x08, 0x65, 0x6e,
-	0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63,
-	0x65, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
-	0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f,
-	0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x43, 0x0a, 0x09, 0x65, 0x78, 0x74,
-	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46,
-	0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
-	0x6f, 0x74, 0x6f, 0x52, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x36,
-	0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f,
-	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x49, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65,
-	0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
-	0x75, 0x66, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66,
-	0x6f, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66,
-	0x6f, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x18, 0x0c, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x06, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x22, 0xb9, 0x06, 0x0a, 0x0f, 0x44, 0x65,
-	0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a,
-	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
-	0x65, 0x12, 0x3b, 0x0a, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
-	0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
-	0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
-	0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x43,
-	0x0a, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70,
-	0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
-	0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x0b, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x79,
-	0x70, 0x65, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
-	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72,
-	0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x0a, 0x6e, 0x65, 0x73, 0x74,
-	0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74,
-	0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
-	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52,
-	0x08, 0x65, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x58, 0x0a, 0x0f, 0x65, 0x78, 0x74,
-	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x05, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50,
-	0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61,
-	0x6e, 0x67, 0x65, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61,
-	0x6e, 0x67, 0x65, 0x12, 0x44, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x64, 0x65, 0x63,
-	0x6c, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x44,
-	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x09,
-	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x65, 0x63, 0x6c, 0x12, 0x39, 0x0a, 0x07, 0x6f, 0x70, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x12, 0x55, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64,
-	0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44,
-	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x52,
-	0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0d, 0x72, 0x65,
-	0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72,
-	0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x03,
-	0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x61, 0x6d, 0x65,
-	0x1a, 0x7a, 0x0a, 0x0e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e,
-	0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x05, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x07, 0x6f, 0x70,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f,
-	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x78,
-	0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x37, 0x0a, 0x0d,
-	0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a,
-	0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74,
-	0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05,
-	0x52, 0x03, 0x65, 0x6e, 0x64, 0x22, 0x7c, 0x0a, 0x15, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69,
-	0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x58,
-	0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f,
-	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
-	0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74,
-	0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74,
-	0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80,
-	0x80, 0x80, 0x02, 0x22, 0xc1, 0x06, 0x0a, 0x14, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73,
-	0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04,
-	0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
-	0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05,
-	0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x41, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65,
-	0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44,
-	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x4c,
-	0x61, 0x62, 0x65, 0x6c, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x3e, 0x0a, 0x04, 0x74,
-	0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c,
-	0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f,
-	0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x74,
-	0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
-	0x74, 0x79, 0x70, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x74, 0x65,
-	0x6e, 0x64, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x74, 0x65,
-	0x6e, 0x64, 0x65, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f,
-	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x66,
-	0x61, 0x75, 0x6c, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x6e, 0x65,
-	0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
-	0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1b, 0x0a, 0x09, 0x6a, 0x73,
-	0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6a,
-	0x73, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
-	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64,
-	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x12, 0x27, 0x0a, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
-	0x6e, 0x61, 0x6c, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x33, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x22, 0xb6, 0x02, 0x0a, 0x04, 0x54, 0x79,
-	0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x4f, 0x55, 0x42, 0x4c,
-	0x45, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x41,
-	0x54, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x36,
-	0x34, 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54,
-	0x36, 0x34, 0x10, 0x04, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54,
-	0x33, 0x32, 0x10, 0x05, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x49, 0x58,
-	0x45, 0x44, 0x36, 0x34, 0x10, 0x06, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46,
-	0x49, 0x58, 0x45, 0x44, 0x33, 0x32, 0x10, 0x07, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x59, 0x50, 0x45,
-	0x5f, 0x42, 0x4f, 0x4f, 0x4c, 0x10, 0x08, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f,
-	0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x09, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45,
-	0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x10, 0x0a, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45,
-	0x5f, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x10, 0x0b, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59,
-	0x50, 0x45, 0x5f, 0x42, 0x59, 0x54, 0x45, 0x53, 0x10, 0x0c, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59,
-	0x50, 0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10, 0x0d, 0x12, 0x0d, 0x0a, 0x09, 0x54,
-	0x59, 0x50, 0x45, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x10, 0x0e, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59,
-	0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x33, 0x32, 0x10, 0x0f, 0x12, 0x11, 0x0a,
-	0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x36, 0x34, 0x10, 0x10,
-	0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10,
-	0x11, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4e, 0x54, 0x36, 0x34,
-	0x10, 0x12, 0x22, 0x43, 0x0a, 0x05, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x12, 0x0a, 0x0e, 0x4c,
-	0x41, 0x42, 0x45, 0x4c, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x41, 0x4c, 0x10, 0x01, 0x12,
-	0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x49, 0x52, 0x45,
-	0x44, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x52, 0x45, 0x50,
-	0x45, 0x41, 0x54, 0x45, 0x44, 0x10, 0x03, 0x22, 0x63, 0x0a, 0x14, 0x4f, 0x6e, 0x65, 0x6f, 0x66,
-	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12,
-	0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
-	0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xe3, 0x02, 0x0a,
-	0x13, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50,
-	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3f, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
-	0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61,
-	0x6c, 0x75, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f,
-	0x74, 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x36, 0x0a, 0x07, 0x6f, 0x70, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75,
-	0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x12, 0x5d, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x72, 0x61,
-	0x6e, 0x67, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
-	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
-	0x45, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67,
-	0x65, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65,
-	0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d,
-	0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65,
-	0x64, 0x4e, 0x61, 0x6d, 0x65, 0x1a, 0x3b, 0x0a, 0x11, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73,
-	0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74,
-	0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74,
-	0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65,
-	0x6e, 0x64, 0x22, 0x83, 0x01, 0x0a, 0x18, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65,
-	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12,
-	0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
-	0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x05, 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x07, 0x6f,
-	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45,
-	0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52,
-	0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xa7, 0x01, 0x0a, 0x16, 0x53, 0x65, 0x72,
-	0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
-	0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3e, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f,
-	0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64,
-	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52,
-	0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x39, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
-	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69,
-	0x63, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x22, 0x89, 0x02, 0x0a, 0x15, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x44, 0x65, 0x73,
-	0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04,
-	0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
-	0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12,
-	0x1f, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x79, 0x70, 0x65,
-	0x12, 0x38, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x30, 0x0a, 0x10, 0x63, 0x6c,
-	0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x18, 0x05,
-	0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0f, 0x63, 0x6c, 0x69,
-	0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x12, 0x30, 0x0a, 0x10,
-	0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67,
-	0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0f, 0x73,
-	0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x22, 0x91,
-	0x09, 0x0a, 0x0b, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21,
-	0x0a, 0x0c, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6a, 0x61, 0x76, 0x61, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67,
-	0x65, 0x12, 0x30, 0x0a, 0x14, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f,
-	0x63, 0x6c, 0x61, 0x73, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x12, 0x6a, 0x61, 0x76, 0x61, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x6e,
-	0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x13, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6d, 0x75, 0x6c, 0x74,
-	0x69, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08,
-	0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x6a, 0x61, 0x76, 0x61, 0x4d, 0x75, 0x6c,
-	0x74, 0x69, 0x70, 0x6c, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x44, 0x0a, 0x1d, 0x6a, 0x61,
-	0x76, 0x61, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x65, 0x71, 0x75, 0x61,
-	0x6c, 0x73, 0x5f, 0x61, 0x6e, 0x64, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x14, 0x20, 0x01, 0x28,
-	0x08, 0x42, 0x02, 0x18, 0x01, 0x52, 0x19, 0x6a, 0x61, 0x76, 0x61, 0x47, 0x65, 0x6e, 0x65, 0x72,
-	0x61, 0x74, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x73, 0x41, 0x6e, 0x64, 0x48, 0x61, 0x73, 0x68,
-	0x12, 0x3a, 0x0a, 0x16, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f,
-	0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x75, 0x74, 0x66, 0x38, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x08,
-	0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x13, 0x6a, 0x61, 0x76, 0x61, 0x53, 0x74, 0x72,
-	0x69, 0x6e, 0x67, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x55, 0x74, 0x66, 0x38, 0x12, 0x53, 0x0a, 0x0c,
-	0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01,
-	0x28, 0x0e, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x2e, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x3a, 0x05, 0x53,
-	0x50, 0x45, 0x45, 0x44, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x46, 0x6f,
-	0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x6f, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18,
-	0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x67, 0x6f, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65,
-	0x12, 0x35, 0x0a, 0x13, 0x63, 0x63, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73,
-	0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66,
-	0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x63, 0x63, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53,
-	0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x15, 0x6a, 0x61, 0x76, 0x61, 0x5f,
-	0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73,
-	0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x13, 0x6a,
-	0x61, 0x76, 0x61, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
-	0x65, 0x73, 0x12, 0x35, 0x0a, 0x13, 0x70, 0x79, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63,
-	0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x3a,
-	0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x70, 0x79, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69,
-	0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x37, 0x0a, 0x14, 0x70, 0x68, 0x70,
-	0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
-	0x73, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x12,
-	0x70, 0x68, 0x70, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
-	0x65, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64,
-	0x18, 0x17, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64,
-	0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x2e, 0x0a, 0x10, 0x63, 0x63, 0x5f,
-	0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x61, 0x72, 0x65, 0x6e, 0x61, 0x73, 0x18, 0x1f, 0x20,
-	0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x0e, 0x63, 0x63, 0x45, 0x6e, 0x61,
-	0x62, 0x6c, 0x65, 0x41, 0x72, 0x65, 0x6e, 0x61, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x6f, 0x62, 0x6a,
-	0x63, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x24,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6f, 0x62, 0x6a, 0x63, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x50,
-	0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x5f,
-	0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x25, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0f, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65,
-	0x12, 0x21, 0x0a, 0x0c, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78,
-	0x18, 0x27, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x77, 0x69, 0x66, 0x74, 0x50, 0x72, 0x65,
-	0x66, 0x69, 0x78, 0x12, 0x28, 0x0a, 0x10, 0x70, 0x68, 0x70, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73,
-	0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x28, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70,
-	0x68, 0x70, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x23, 0x0a,
-	0x0d, 0x70, 0x68, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x29,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x68, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
-	0x63, 0x65, 0x12, 0x34, 0x0a, 0x16, 0x70, 0x68, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
-	0x74, 0x61, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x2c, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x14, 0x70, 0x68, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4e,
-	0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x75, 0x62, 0x79,
-	0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
-	0x72, 0x75, 0x62, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x58, 0x0a, 0x14, 0x75,
-	0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74,
-	0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69,
-	0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-	0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f,
-	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x0a, 0x0c, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a,
-	0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x50, 0x45, 0x45, 0x44, 0x10, 0x01,
-	0x12, 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x53, 0x49, 0x5a, 0x45, 0x10, 0x02, 0x12,
-	0x10, 0x0a, 0x0c, 0x4c, 0x49, 0x54, 0x45, 0x5f, 0x52, 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10,
-	0x03, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x26,
-	0x10, 0x27, 0x22, 0xd1, 0x02, 0x0a, 0x0e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3c, 0x0a, 0x17, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x5f, 0x73, 0x65, 0x74, 0x5f, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x14, 0x6d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72,
-	0x6d, 0x61, 0x74, 0x12, 0x4c, 0x0a, 0x1f, 0x6e, 0x6f, 0x5f, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61,
-	0x72, 0x64, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x63,
-	0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61,
-	0x6c, 0x73, 0x65, 0x52, 0x1c, 0x6e, 0x6f, 0x53, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x44,
-	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f,
-	0x72, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65,
-	0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x70, 0x5f,
-	0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6d, 0x61, 0x70,
-	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72,
-	0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72,
-	0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e,
-	0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a,
-	0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x08, 0x10, 0x09,
-	0x4a, 0x04, 0x08, 0x09, 0x10, 0x0a, 0x22, 0xe2, 0x03, 0x0a, 0x0c, 0x46, 0x69, 0x65, 0x6c, 0x64,
-	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x41, 0x0a, 0x05, 0x63, 0x74, 0x79, 0x70, 0x65,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x43, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x06, 0x53, 0x54, 0x52,
-	0x49, 0x4e, 0x47, 0x52, 0x05, 0x63, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61,
-	0x63, 0x6b, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x70, 0x61, 0x63, 0x6b,
-	0x65, 0x64, 0x12, 0x47, 0x0a, 0x06, 0x6a, 0x73, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01,
-	0x28, 0x0e, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x2e, 0x4a, 0x53, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x09, 0x4a, 0x53, 0x5f, 0x4e, 0x4f, 0x52,
-	0x4d, 0x41, 0x4c, 0x52, 0x06, 0x6a, 0x73, 0x74, 0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x04, 0x6c,
-	0x61, 0x7a, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65,
-	0x52, 0x04, 0x6c, 0x61, 0x7a, 0x79, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63,
-	0x61, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73,
-	0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a,
-	0x04, 0x77, 0x65, 0x61, 0x6b, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c,
-	0x73, 0x65, 0x52, 0x04, 0x77, 0x65, 0x61, 0x6b, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e,
-	0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-	0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65,
-	0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75,
-	0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x22, 0x2f, 0x0a, 0x05, 0x43, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x53,
-	0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x43, 0x4f, 0x52, 0x44, 0x10,
-	0x01, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x50, 0x49, 0x45, 0x43,
-	0x45, 0x10, 0x02, 0x22, 0x35, 0x0a, 0x06, 0x4a, 0x53, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0d, 0x0a,
-	0x09, 0x4a, 0x53, 0x5f, 0x4e, 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09,
-	0x4a, 0x53, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x4a,
-	0x53, 0x5f, 0x4e, 0x55, 0x4d, 0x42, 0x45, 0x52, 0x10, 0x02, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10,
-	0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x22, 0x73, 0x0a, 0x0c, 0x4f,
-	0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x58, 0x0a, 0x14, 0x75,
-	0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74,
-	0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69,
-	0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-	0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f,
-	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02,
-	0x22, 0xc0, 0x01, 0x0a, 0x0b, 0x45, 0x6e, 0x75, 0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x41, 0x6c, 0x69, 0x61,
-	0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65,
-	0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e,
-	0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-	0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65,
-	0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75,
-	0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08,
-	0x05, 0x10, 0x06, 0x22, 0x9e, 0x01, 0x0a, 0x10, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75,
-	0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72,
-	0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61,
-	0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12,
-	0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64,
-	0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24,
-	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65,
-	0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80,
-	0x80, 0x80, 0x80, 0x02, 0x22, 0x9c, 0x01, 0x0a, 0x0e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
-	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65,
-	0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c,
-	0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x58,
-	0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f,
-	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
-	0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74,
-	0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74,
-	0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80,
-	0x80, 0x80, 0x02, 0x22, 0xe0, 0x02, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61,
-	0x74, 0x65, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65,
-	0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x71, 0x0a, 0x11,
-	0x69, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x6c, 0x65, 0x76, 0x65,
-	0x6c, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64,
-	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x49, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65,
-	0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x3a, 0x13, 0x49, 0x44, 0x45, 0x4d, 0x50, 0x4f,
-	0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x52, 0x10, 0x69,
-	0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12,
-	0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64,
-	0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24,
-	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65,
-	0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x50, 0x0a, 0x10, 0x49, 0x64, 0x65,
-	0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x17, 0x0a,
-	0x13, 0x49, 0x44, 0x45, 0x4d, 0x50, 0x4f, 0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x4b,
-	0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x4e, 0x4f, 0x5f, 0x53, 0x49, 0x44,
-	0x45, 0x5f, 0x45, 0x46, 0x46, 0x45, 0x43, 0x54, 0x53, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x49,
-	0x44, 0x45, 0x4d, 0x50, 0x4f, 0x54, 0x45, 0x4e, 0x54, 0x10, 0x02, 0x2a, 0x09, 0x08, 0xe8, 0x07,
-	0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x9a, 0x03, 0x0a, 0x13, 0x55, 0x6e, 0x69, 0x6e, 0x74,
-	0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x41,
-	0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55,
-	0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x52, 0x04, 0x6e, 0x61, 0x6d,
-	0x65, 0x12, 0x29, 0x0a, 0x10, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f,
-	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x69, 0x64, 0x65,
-	0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, 0x12,
-	0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c,
-	0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
-	0x76, 0x65, 0x49, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6e, 0x65,
-	0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
-	0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x6e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65,
-	0x49, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x6f, 0x75, 0x62,
-	0x6c, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b,
-	0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73,
-	0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28,
-	0x0c, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x27,
-	0x0a, 0x0f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75,
-	0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61,
-	0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x1a, 0x4a, 0x0a, 0x08, 0x4e, 0x61, 0x6d, 0x65, 0x50,
-	0x61, 0x72, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74,
-	0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74,
-	0x12, 0x21, 0x0a, 0x0c, 0x69, 0x73, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
-	0x18, 0x02, 0x20, 0x02, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x73, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73,
-	0x69, 0x6f, 0x6e, 0x22, 0xa7, 0x02, 0x0a, 0x0e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f,
-	0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x44, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
-	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63,
-	0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0xce, 0x01, 0x0a,
-	0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x04, 0x70, 0x61, 0x74,
-	0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52, 0x04, 0x70, 0x61, 0x74,
-	0x68, 0x12, 0x16, 0x0a, 0x04, 0x73, 0x70, 0x61, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x42,
-	0x02, 0x10, 0x01, 0x52, 0x04, 0x73, 0x70, 0x61, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x6c, 0x65, 0x61,
-	0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x0f, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d,
-	0x65, 0x6e, 0x74, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67,
-	0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x10, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74,
-	0x73, 0x12, 0x3a, 0x0a, 0x19, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x74,
-	0x61, 0x63, 0x68, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x06,
-	0x20, 0x03, 0x28, 0x09, 0x52, 0x17, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x74,
-	0x61, 0x63, 0x68, 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xd1, 0x01,
-	0x0a, 0x11, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, 0x49,
-	0x6e, 0x66, 0x6f, 0x12, 0x4d, 0x0a, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61,
-	0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x41, 0x6e, 0x6e, 0x6f,
-	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x1a, 0x6d, 0x0a, 0x0a, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x12, 0x16, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02,
-	0x10, 0x01, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72,
-	0x63, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73,
-	0x6f, 0x75, 0x72, 0x63, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x65, 0x67,
-	0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x12,
-	0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e,
-	0x64, 0x42, 0x8f, 0x01, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x10, 0x44, 0x65, 0x73, 0x63, 0x72,
-	0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x48, 0x01, 0x5a, 0x3e, 0x67,
-	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
-	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
-	0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
-	0x6f, 0x72, 0x3b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0xf8, 0x01, 0x01,
-	0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1a, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
-	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x52, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74,
-	0x69, 0x6f, 0x6e,
-}
-
-var (
-	file_google_protobuf_descriptor_proto_rawDescOnce sync.Once
-	file_google_protobuf_descriptor_proto_rawDescData = file_google_protobuf_descriptor_proto_rawDesc
-)
-
-func file_google_protobuf_descriptor_proto_rawDescGZIP() []byte {
-	file_google_protobuf_descriptor_proto_rawDescOnce.Do(func() {
-		file_google_protobuf_descriptor_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_descriptor_proto_rawDescData)
-	})
-	return file_google_protobuf_descriptor_proto_rawDescData
-}
-
-var file_google_protobuf_descriptor_proto_enumTypes = make([]protoimpl.EnumInfo, 6)
-var file_google_protobuf_descriptor_proto_msgTypes = make([]protoimpl.MessageInfo, 27)
-var file_google_protobuf_descriptor_proto_goTypes = []interface{}{
-	(FieldDescriptorProto_Type)(0),                // 0: google.protobuf.FieldDescriptorProto.Type
-	(FieldDescriptorProto_Label)(0),               // 1: google.protobuf.FieldDescriptorProto.Label
-	(FileOptions_OptimizeMode)(0),                 // 2: google.protobuf.FileOptions.OptimizeMode
-	(FieldOptions_CType)(0),                       // 3: google.protobuf.FieldOptions.CType
-	(FieldOptions_JSType)(0),                      // 4: google.protobuf.FieldOptions.JSType
-	(MethodOptions_IdempotencyLevel)(0),           // 5: google.protobuf.MethodOptions.IdempotencyLevel
-	(*FileDescriptorSet)(nil),                     // 6: google.protobuf.FileDescriptorSet
-	(*FileDescriptorProto)(nil),                   // 7: google.protobuf.FileDescriptorProto
-	(*DescriptorProto)(nil),                       // 8: google.protobuf.DescriptorProto
-	(*ExtensionRangeOptions)(nil),                 // 9: google.protobuf.ExtensionRangeOptions
-	(*FieldDescriptorProto)(nil),                  // 10: google.protobuf.FieldDescriptorProto
-	(*OneofDescriptorProto)(nil),                  // 11: google.protobuf.OneofDescriptorProto
-	(*EnumDescriptorProto)(nil),                   // 12: google.protobuf.EnumDescriptorProto
-	(*EnumValueDescriptorProto)(nil),              // 13: google.protobuf.EnumValueDescriptorProto
-	(*ServiceDescriptorProto)(nil),                // 14: google.protobuf.ServiceDescriptorProto
-	(*MethodDescriptorProto)(nil),                 // 15: google.protobuf.MethodDescriptorProto
-	(*FileOptions)(nil),                           // 16: google.protobuf.FileOptions
-	(*MessageOptions)(nil),                        // 17: google.protobuf.MessageOptions
-	(*FieldOptions)(nil),                          // 18: google.protobuf.FieldOptions
-	(*OneofOptions)(nil),                          // 19: google.protobuf.OneofOptions
-	(*EnumOptions)(nil),                           // 20: google.protobuf.EnumOptions
-	(*EnumValueOptions)(nil),                      // 21: google.protobuf.EnumValueOptions
-	(*ServiceOptions)(nil),                        // 22: google.protobuf.ServiceOptions
-	(*MethodOptions)(nil),                         // 23: google.protobuf.MethodOptions
-	(*UninterpretedOption)(nil),                   // 24: google.protobuf.UninterpretedOption
-	(*SourceCodeInfo)(nil),                        // 25: google.protobuf.SourceCodeInfo
-	(*GeneratedCodeInfo)(nil),                     // 26: google.protobuf.GeneratedCodeInfo
-	(*DescriptorProto_ExtensionRange)(nil),        // 27: google.protobuf.DescriptorProto.ExtensionRange
-	(*DescriptorProto_ReservedRange)(nil),         // 28: google.protobuf.DescriptorProto.ReservedRange
-	(*EnumDescriptorProto_EnumReservedRange)(nil), // 29: google.protobuf.EnumDescriptorProto.EnumReservedRange
-	(*UninterpretedOption_NamePart)(nil),          // 30: google.protobuf.UninterpretedOption.NamePart
-	(*SourceCodeInfo_Location)(nil),               // 31: google.protobuf.SourceCodeInfo.Location
-	(*GeneratedCodeInfo_Annotation)(nil),          // 32: google.protobuf.GeneratedCodeInfo.Annotation
-}
-var file_google_protobuf_descriptor_proto_depIdxs = []int32{
-	7,  // 0: google.protobuf.FileDescriptorSet.file:type_name -> google.protobuf.FileDescriptorProto
-	8,  // 1: google.protobuf.FileDescriptorProto.message_type:type_name -> google.protobuf.DescriptorProto
-	12, // 2: google.protobuf.FileDescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
-	14, // 3: google.protobuf.FileDescriptorProto.service:type_name -> google.protobuf.ServiceDescriptorProto
-	10, // 4: google.protobuf.FileDescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
-	16, // 5: google.protobuf.FileDescriptorProto.options:type_name -> google.protobuf.FileOptions
-	25, // 6: google.protobuf.FileDescriptorProto.source_code_info:type_name -> google.protobuf.SourceCodeInfo
-	10, // 7: google.protobuf.DescriptorProto.field:type_name -> google.protobuf.FieldDescriptorProto
-	10, // 8: google.protobuf.DescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
-	8,  // 9: google.protobuf.DescriptorProto.nested_type:type_name -> google.protobuf.DescriptorProto
-	12, // 10: google.protobuf.DescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
-	27, // 11: google.protobuf.DescriptorProto.extension_range:type_name -> google.protobuf.DescriptorProto.ExtensionRange
-	11, // 12: google.protobuf.DescriptorProto.oneof_decl:type_name -> google.protobuf.OneofDescriptorProto
-	17, // 13: google.protobuf.DescriptorProto.options:type_name -> google.protobuf.MessageOptions
-	28, // 14: google.protobuf.DescriptorProto.reserved_range:type_name -> google.protobuf.DescriptorProto.ReservedRange
-	24, // 15: google.protobuf.ExtensionRangeOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
-	1,  // 16: google.protobuf.FieldDescriptorProto.label:type_name -> google.protobuf.FieldDescriptorProto.Label
-	0,  // 17: google.protobuf.FieldDescriptorProto.type:type_name -> google.protobuf.FieldDescriptorProto.Type
-	18, // 18: google.protobuf.FieldDescriptorProto.options:type_name -> google.protobuf.FieldOptions
-	19, // 19: google.protobuf.OneofDescriptorProto.options:type_name -> google.protobuf.OneofOptions
-	13, // 20: google.protobuf.EnumDescriptorProto.value:type_name -> google.protobuf.EnumValueDescriptorProto
-	20, // 21: google.protobuf.EnumDescriptorProto.options:type_name -> google.protobuf.EnumOptions
-	29, // 22: google.protobuf.EnumDescriptorProto.reserved_range:type_name -> google.protobuf.EnumDescriptorProto.EnumReservedRange
-	21, // 23: google.protobuf.EnumValueDescriptorProto.options:type_name -> google.protobuf.EnumValueOptions
-	15, // 24: google.protobuf.ServiceDescriptorProto.method:type_name -> google.protobuf.MethodDescriptorProto
-	22, // 25: google.protobuf.ServiceDescriptorProto.options:type_name -> google.protobuf.ServiceOptions
-	23, // 26: google.protobuf.MethodDescriptorProto.options:type_name -> google.protobuf.MethodOptions
-	2,  // 27: google.protobuf.FileOptions.optimize_for:type_name -> google.protobuf.FileOptions.OptimizeMode
-	24, // 28: google.protobuf.FileOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
-	24, // 29: google.protobuf.MessageOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
-	3,  // 30: google.protobuf.FieldOptions.ctype:type_name -> google.protobuf.FieldOptions.CType
-	4,  // 31: google.protobuf.FieldOptions.jstype:type_name -> google.protobuf.FieldOptions.JSType
-	24, // 32: google.protobuf.FieldOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
-	24, // 33: google.protobuf.OneofOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
-	24, // 34: google.protobuf.EnumOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
-	24, // 35: google.protobuf.EnumValueOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
-	24, // 36: google.protobuf.ServiceOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
-	5,  // 37: google.protobuf.MethodOptions.idempotency_level:type_name -> google.protobuf.MethodOptions.IdempotencyLevel
-	24, // 38: google.protobuf.MethodOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
-	30, // 39: google.protobuf.UninterpretedOption.name:type_name -> google.protobuf.UninterpretedOption.NamePart
-	31, // 40: google.protobuf.SourceCodeInfo.location:type_name -> google.protobuf.SourceCodeInfo.Location
-	32, // 41: google.protobuf.GeneratedCodeInfo.annotation:type_name -> google.protobuf.GeneratedCodeInfo.Annotation
-	9,  // 42: google.protobuf.DescriptorProto.ExtensionRange.options:type_name -> google.protobuf.ExtensionRangeOptions
-	43, // [43:43] is the sub-list for method output_type
-	43, // [43:43] is the sub-list for method input_type
-	43, // [43:43] is the sub-list for extension type_name
-	43, // [43:43] is the sub-list for extension extendee
-	0,  // [0:43] is the sub-list for field type_name
-}
-
-func init() { file_google_protobuf_descriptor_proto_init() }
-func file_google_protobuf_descriptor_proto_init() {
-	if File_google_protobuf_descriptor_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_google_protobuf_descriptor_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*FileDescriptorSet); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*FileDescriptorProto); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DescriptorProto); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ExtensionRangeOptions); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			case 3:
-				return &v.extensionFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*FieldDescriptorProto); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*OneofDescriptorProto); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*EnumDescriptorProto); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*EnumValueDescriptorProto); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ServiceDescriptorProto); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MethodDescriptorProto); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*FileOptions); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			case 3:
-				return &v.extensionFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MessageOptions); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			case 3:
-				return &v.extensionFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*FieldOptions); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			case 3:
-				return &v.extensionFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*OneofOptions); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			case 3:
-				return &v.extensionFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*EnumOptions); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			case 3:
-				return &v.extensionFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*EnumValueOptions); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			case 3:
-				return &v.extensionFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ServiceOptions); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			case 3:
-				return &v.extensionFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MethodOptions); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			case 3:
-				return &v.extensionFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*UninterpretedOption); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SourceCodeInfo); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*GeneratedCodeInfo); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DescriptorProto_ExtensionRange); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DescriptorProto_ReservedRange); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*EnumDescriptorProto_EnumReservedRange); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*UninterpretedOption_NamePart); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SourceCodeInfo_Location); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_descriptor_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*GeneratedCodeInfo_Annotation); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_google_protobuf_descriptor_proto_rawDesc,
-			NumEnums:      6,
-			NumMessages:   27,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_google_protobuf_descriptor_proto_goTypes,
-		DependencyIndexes: file_google_protobuf_descriptor_proto_depIdxs,
-		EnumInfos:         file_google_protobuf_descriptor_proto_enumTypes,
-		MessageInfos:      file_google_protobuf_descriptor_proto_msgTypes,
-	}.Build()
-	File_google_protobuf_descriptor_proto = out.File
-	file_google_protobuf_descriptor_proto_rawDesc = nil
-	file_google_protobuf_descriptor_proto_goTypes = nil
-	file_google_protobuf_descriptor_proto_depIdxs = nil
-}
diff --git a/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go b/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
deleted file mode 100644
index 5f9498e..0000000
--- a/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
+++ /dev/null
@@ -1,287 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/any.proto
-
-package anypb
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-// `Any` contains an arbitrary serialized protocol buffer message along with a
-// URL that describes the type of the serialized message.
-//
-// Protobuf library provides support to pack/unpack Any values in the form
-// of utility functions or additional generated methods of the Any type.
-//
-// Example 1: Pack and unpack a message in C++.
-//
-//     Foo foo = ...;
-//     Any any;
-//     any.PackFrom(foo);
-//     ...
-//     if (any.UnpackTo(&foo)) {
-//       ...
-//     }
-//
-// Example 2: Pack and unpack a message in Java.
-//
-//     Foo foo = ...;
-//     Any any = Any.pack(foo);
-//     ...
-//     if (any.is(Foo.class)) {
-//       foo = any.unpack(Foo.class);
-//     }
-//
-//  Example 3: Pack and unpack a message in Python.
-//
-//     foo = Foo(...)
-//     any = Any()
-//     any.Pack(foo)
-//     ...
-//     if any.Is(Foo.DESCRIPTOR):
-//       any.Unpack(foo)
-//       ...
-//
-//  Example 4: Pack and unpack a message in Go
-//
-//      foo := &pb.Foo{...}
-//      any, err := ptypes.MarshalAny(foo)
-//      ...
-//      foo := &pb.Foo{}
-//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
-//        ...
-//      }
-//
-// The pack methods provided by protobuf library will by default use
-// 'type.googleapis.com/full.type.name' as the type URL and the unpack
-// methods only use the fully qualified type name after the last '/'
-// in the type URL, for example "foo.bar.com/x/y.z" will yield type
-// name "y.z".
-//
-//
-// JSON
-// ====
-// The JSON representation of an `Any` value uses the regular
-// representation of the deserialized, embedded message, with an
-// additional field `@type` which contains the type URL. Example:
-//
-//     package google.profile;
-//     message Person {
-//       string first_name = 1;
-//       string last_name = 2;
-//     }
-//
-//     {
-//       "@type": "type.googleapis.com/google.profile.Person",
-//       "firstName": <string>,
-//       "lastName": <string>
-//     }
-//
-// If the embedded message type is well-known and has a custom JSON
-// representation, that representation will be embedded adding a field
-// `value` which holds the custom JSON in addition to the `@type`
-// field. Example (for message [google.protobuf.Duration][]):
-//
-//     {
-//       "@type": "type.googleapis.com/google.protobuf.Duration",
-//       "value": "1.212s"
-//     }
-//
-type Any struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// A URL/resource name that uniquely identifies the type of the serialized
-	// protocol buffer message. This string must contain at least
-	// one "/" character. The last segment of the URL's path must represent
-	// the fully qualified name of the type (as in
-	// `path/google.protobuf.Duration`). The name should be in a canonical form
-	// (e.g., leading "." is not accepted).
-	//
-	// In practice, teams usually precompile into the binary all types that they
-	// expect it to use in the context of Any. However, for URLs which use the
-	// scheme `http`, `https`, or no scheme, one can optionally set up a type
-	// server that maps type URLs to message definitions as follows:
-	//
-	// * If no scheme is provided, `https` is assumed.
-	// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
-	//   value in binary format, or produce an error.
-	// * Applications are allowed to cache lookup results based on the
-	//   URL, or have them precompiled into a binary to avoid any
-	//   lookup. Therefore, binary compatibility needs to be preserved
-	//   on changes to types. (Use versioned type names to manage
-	//   breaking changes.)
-	//
-	// Note: this functionality is not currently available in the official
-	// protobuf release, and it is not used for type URLs beginning with
-	// type.googleapis.com.
-	//
-	// Schemes other than `http`, `https` (or the empty scheme) might be
-	// used with implementation specific semantics.
-	//
-	TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"`
-	// Must be a valid serialized protocol buffer of the above specified type.
-	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *Any) Reset() {
-	*x = Any{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_any_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Any) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Any) ProtoMessage() {}
-
-func (x *Any) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_any_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Any.ProtoReflect.Descriptor instead.
-func (*Any) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_any_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *Any) GetTypeUrl() string {
-	if x != nil {
-		return x.TypeUrl
-	}
-	return ""
-}
-
-func (x *Any) GetValue() []byte {
-	if x != nil {
-		return x.Value
-	}
-	return nil
-}
-
-var File_google_protobuf_any_proto protoreflect.FileDescriptor
-
-var file_google_protobuf_any_proto_rawDesc = []byte{
-	0x0a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x22, 0x36, 0x0a, 0x03,
-	0x41, 0x6e, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x79, 0x70, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x14,
-	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76,
-	0x61, 0x6c, 0x75, 0x65, 0x42, 0x6f, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x08, 0x41, 0x6e, 0x79,
-	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x25, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
-	0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x61, 0x6e, 0x79, 0xa2, 0x02,
-	0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e,
-	0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_google_protobuf_any_proto_rawDescOnce sync.Once
-	file_google_protobuf_any_proto_rawDescData = file_google_protobuf_any_proto_rawDesc
-)
-
-func file_google_protobuf_any_proto_rawDescGZIP() []byte {
-	file_google_protobuf_any_proto_rawDescOnce.Do(func() {
-		file_google_protobuf_any_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_any_proto_rawDescData)
-	})
-	return file_google_protobuf_any_proto_rawDescData
-}
-
-var file_google_protobuf_any_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_google_protobuf_any_proto_goTypes = []interface{}{
-	(*Any)(nil), // 0: google.protobuf.Any
-}
-var file_google_protobuf_any_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
-}
-
-func init() { file_google_protobuf_any_proto_init() }
-func file_google_protobuf_any_proto_init() {
-	if File_google_protobuf_any_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_google_protobuf_any_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Any); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_google_protobuf_any_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   1,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_google_protobuf_any_proto_goTypes,
-		DependencyIndexes: file_google_protobuf_any_proto_depIdxs,
-		MessageInfos:      file_google_protobuf_any_proto_msgTypes,
-	}.Build()
-	File_google_protobuf_any_proto = out.File
-	file_google_protobuf_any_proto_rawDesc = nil
-	file_google_protobuf_any_proto_goTypes = nil
-	file_google_protobuf_any_proto_depIdxs = nil
-}
diff --git a/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go b/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
deleted file mode 100644
index 3997c60..0000000
--- a/vendor/google.golang.org/protobuf/types/known/durationpb/duration.pb.go
+++ /dev/null
@@ -1,249 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/duration.proto
-
-package durationpb
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-// A Duration represents a signed, fixed-length span of time represented
-// as a count of seconds and fractions of seconds at nanosecond
-// resolution. It is independent of any calendar and concepts like "day"
-// or "month". It is related to Timestamp in that the difference between
-// two Timestamp values is a Duration and it can be added or subtracted
-// from a Timestamp. Range is approximately +-10,000 years.
-//
-// # Examples
-//
-// Example 1: Compute Duration from two Timestamps in pseudo code.
-//
-//     Timestamp start = ...;
-//     Timestamp end = ...;
-//     Duration duration = ...;
-//
-//     duration.seconds = end.seconds - start.seconds;
-//     duration.nanos = end.nanos - start.nanos;
-//
-//     if (duration.seconds < 0 && duration.nanos > 0) {
-//       duration.seconds += 1;
-//       duration.nanos -= 1000000000;
-//     } else if (duration.seconds > 0 && duration.nanos < 0) {
-//       duration.seconds -= 1;
-//       duration.nanos += 1000000000;
-//     }
-//
-// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
-//
-//     Timestamp start = ...;
-//     Duration duration = ...;
-//     Timestamp end = ...;
-//
-//     end.seconds = start.seconds + duration.seconds;
-//     end.nanos = start.nanos + duration.nanos;
-//
-//     if (end.nanos < 0) {
-//       end.seconds -= 1;
-//       end.nanos += 1000000000;
-//     } else if (end.nanos >= 1000000000) {
-//       end.seconds += 1;
-//       end.nanos -= 1000000000;
-//     }
-//
-// Example 3: Compute Duration from datetime.timedelta in Python.
-//
-//     td = datetime.timedelta(days=3, minutes=10)
-//     duration = Duration()
-//     duration.FromTimedelta(td)
-//
-// # JSON Mapping
-//
-// In JSON format, the Duration type is encoded as a string rather than an
-// object, where the string ends in the suffix "s" (indicating seconds) and
-// is preceded by the number of seconds, with nanoseconds expressed as
-// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
-// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
-// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
-// microsecond should be expressed in JSON format as "3.000001s".
-//
-//
-type Duration struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// Signed seconds of the span of time. Must be from -315,576,000,000
-	// to +315,576,000,000 inclusive. Note: these bounds are computed from:
-	// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
-	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
-	// Signed fractions of a second at nanosecond resolution of the span
-	// of time. Durations less than one second are represented with a 0
-	// `seconds` field and a positive or negative `nanos` field. For durations
-	// of one second or more, a non-zero value for the `nanos` field must be
-	// of the same sign as the `seconds` field. Must be from -999,999,999
-	// to +999,999,999 inclusive.
-	Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
-}
-
-func (x *Duration) Reset() {
-	*x = Duration{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_duration_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Duration) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Duration) ProtoMessage() {}
-
-func (x *Duration) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_duration_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Duration.ProtoReflect.Descriptor instead.
-func (*Duration) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_duration_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *Duration) GetSeconds() int64 {
-	if x != nil {
-		return x.Seconds
-	}
-	return 0
-}
-
-func (x *Duration) GetNanos() int32 {
-	if x != nil {
-		return x.Nanos
-	}
-	return 0
-}
-
-var File_google_protobuf_duration_proto protoreflect.FileDescriptor
-
-var file_google_protobuf_duration_proto_rawDesc = []byte{
-	0x0a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x22, 0x3a, 0x0a, 0x08, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a,
-	0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07,
-	0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6e, 0x6f, 0x73,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x42, 0x7c, 0x0a,
-	0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x42, 0x0d, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72,
-	0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
-	0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c,
-	0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x33,
-}
-
-var (
-	file_google_protobuf_duration_proto_rawDescOnce sync.Once
-	file_google_protobuf_duration_proto_rawDescData = file_google_protobuf_duration_proto_rawDesc
-)
-
-func file_google_protobuf_duration_proto_rawDescGZIP() []byte {
-	file_google_protobuf_duration_proto_rawDescOnce.Do(func() {
-		file_google_protobuf_duration_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_duration_proto_rawDescData)
-	})
-	return file_google_protobuf_duration_proto_rawDescData
-}
-
-var file_google_protobuf_duration_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_google_protobuf_duration_proto_goTypes = []interface{}{
-	(*Duration)(nil), // 0: google.protobuf.Duration
-}
-var file_google_protobuf_duration_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
-}
-
-func init() { file_google_protobuf_duration_proto_init() }
-func file_google_protobuf_duration_proto_init() {
-	if File_google_protobuf_duration_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_google_protobuf_duration_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Duration); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_google_protobuf_duration_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   1,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_google_protobuf_duration_proto_goTypes,
-		DependencyIndexes: file_google_protobuf_duration_proto_depIdxs,
-		MessageInfos:      file_google_protobuf_duration_proto_msgTypes,
-	}.Build()
-	File_google_protobuf_duration_proto = out.File
-	file_google_protobuf_duration_proto_rawDesc = nil
-	file_google_protobuf_duration_proto_goTypes = nil
-	file_google_protobuf_duration_proto_depIdxs = nil
-}
diff --git a/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go b/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
deleted file mode 100644
index 32a583d..0000000
--- a/vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go
+++ /dev/null
@@ -1,168 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/empty.proto
-
-package emptypb
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-// A generic empty message that you can re-use to avoid defining duplicated
-// empty messages in your APIs. A typical example is to use it as the request
-// or the response type of an API method. For instance:
-//
-//     service Foo {
-//       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
-//     }
-//
-// The JSON representation for `Empty` is empty JSON object `{}`.
-type Empty struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-}
-
-func (x *Empty) Reset() {
-	*x = Empty{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_empty_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Empty) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Empty) ProtoMessage() {}
-
-func (x *Empty) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_empty_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Empty.ProtoReflect.Descriptor instead.
-func (*Empty) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_empty_proto_rawDescGZIP(), []int{0}
-}
-
-var File_google_protobuf_empty_proto protoreflect.FileDescriptor
-
-var file_google_protobuf_empty_proto_rawDesc = []byte{
-	0x0a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x22, 0x07,
-	0x0a, 0x05, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x42, 0x76, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x0a,
-	0x45, 0x6d, 0x70, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x27, 0x67, 0x69,
-	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f,
-	0x65, 0x6d, 0x70, 0x74, 0x79, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02,
-	0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62,
-	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_google_protobuf_empty_proto_rawDescOnce sync.Once
-	file_google_protobuf_empty_proto_rawDescData = file_google_protobuf_empty_proto_rawDesc
-)
-
-func file_google_protobuf_empty_proto_rawDescGZIP() []byte {
-	file_google_protobuf_empty_proto_rawDescOnce.Do(func() {
-		file_google_protobuf_empty_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_empty_proto_rawDescData)
-	})
-	return file_google_protobuf_empty_proto_rawDescData
-}
-
-var file_google_protobuf_empty_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_google_protobuf_empty_proto_goTypes = []interface{}{
-	(*Empty)(nil), // 0: google.protobuf.Empty
-}
-var file_google_protobuf_empty_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
-}
-
-func init() { file_google_protobuf_empty_proto_init() }
-func file_google_protobuf_empty_proto_init() {
-	if File_google_protobuf_empty_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_google_protobuf_empty_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Empty); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_google_protobuf_empty_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   1,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_google_protobuf_empty_proto_goTypes,
-		DependencyIndexes: file_google_protobuf_empty_proto_depIdxs,
-		MessageInfos:      file_google_protobuf_empty_proto_msgTypes,
-	}.Build()
-	File_google_protobuf_empty_proto = out.File
-	file_google_protobuf_empty_proto_rawDesc = nil
-	file_google_protobuf_empty_proto_goTypes = nil
-	file_google_protobuf_empty_proto_depIdxs = nil
-}
diff --git a/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go b/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
deleted file mode 100644
index 6fe6d42..0000000
--- a/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
+++ /dev/null
@@ -1,271 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/timestamp.proto
-
-package timestamppb
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-// A Timestamp represents a point in time independent of any time zone or local
-// calendar, encoded as a count of seconds and fractions of seconds at
-// nanosecond resolution. The count is relative to an epoch at UTC midnight on
-// January 1, 1970, in the proleptic Gregorian calendar which extends the
-// Gregorian calendar backwards to year one.
-//
-// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
-// second table is needed for interpretation, using a [24-hour linear
-// smear](https://developers.google.com/time/smear).
-//
-// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
-// restricting to that range, we ensure that we can convert to and from [RFC
-// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
-//
-// # Examples
-//
-// Example 1: Compute Timestamp from POSIX `time()`.
-//
-//     Timestamp timestamp;
-//     timestamp.set_seconds(time(NULL));
-//     timestamp.set_nanos(0);
-//
-// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
-//
-//     struct timeval tv;
-//     gettimeofday(&tv, NULL);
-//
-//     Timestamp timestamp;
-//     timestamp.set_seconds(tv.tv_sec);
-//     timestamp.set_nanos(tv.tv_usec * 1000);
-//
-// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
-//
-//     FILETIME ft;
-//     GetSystemTimeAsFileTime(&ft);
-//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
-//
-//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
-//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
-//     Timestamp timestamp;
-//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
-//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
-//
-// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
-//
-//     long millis = System.currentTimeMillis();
-//
-//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
-//         .setNanos((int) ((millis % 1000) * 1000000)).build();
-//
-//
-// Example 5: Compute Timestamp from current time in Python.
-//
-//     timestamp = Timestamp()
-//     timestamp.GetCurrentTime()
-//
-// # JSON Mapping
-//
-// In JSON format, the Timestamp type is encoded as a string in the
-// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
-// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
-// where {year} is always expressed using four digits while {month}, {day},
-// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
-// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
-// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
-// is required. A proto3 JSON serializer should always use UTC (as indicated by
-// "Z") when printing the Timestamp type and a proto3 JSON parser should be
-// able to accept both UTC and other timezones (as indicated by an offset).
-//
-// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
-// 01:30 UTC on January 15, 2017.
-//
-// In JavaScript, one can convert a Date object to this format using the
-// standard
-// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
-// method. In Python, a standard `datetime.datetime` object can be converted
-// to this format using
-// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
-// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
-// the Joda Time's [`ISODateTimeFormat.dateTime()`](
-// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
-// ) to obtain a formatter capable of generating timestamps in this format.
-//
-//
-type Timestamp struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// Represents seconds of UTC time since Unix epoch
-	// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
-	// 9999-12-31T23:59:59Z inclusive.
-	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
-	// Non-negative fractions of a second at nanosecond resolution. Negative
-	// second values with fractions must still have non-negative nanos values
-	// that count forward in time. Must be from 0 to 999,999,999
-	// inclusive.
-	Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
-}
-
-func (x *Timestamp) Reset() {
-	*x = Timestamp{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_timestamp_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Timestamp) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Timestamp) ProtoMessage() {}
-
-func (x *Timestamp) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_timestamp_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Timestamp.ProtoReflect.Descriptor instead.
-func (*Timestamp) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_timestamp_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *Timestamp) GetSeconds() int64 {
-	if x != nil {
-		return x.Seconds
-	}
-	return 0
-}
-
-func (x *Timestamp) GetNanos() int32 {
-	if x != nil {
-		return x.Nanos
-	}
-	return 0
-}
-
-var File_google_protobuf_timestamp_proto protoreflect.FileDescriptor
-
-var file_google_protobuf_timestamp_proto_rawDesc = []byte{
-	0x0a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
-	0x75, 0x66, 0x22, 0x3b, 0x0a, 0x09, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12,
-	0x18, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03,
-	0x52, 0x07, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6e,
-	0x6f, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x42,
-	0x7e, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x0e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
-	0x70, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65,
-	0x73, 0x74, 0x61, 0x6d, 0x70, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02,
-	0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62,
-	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_google_protobuf_timestamp_proto_rawDescOnce sync.Once
-	file_google_protobuf_timestamp_proto_rawDescData = file_google_protobuf_timestamp_proto_rawDesc
-)
-
-func file_google_protobuf_timestamp_proto_rawDescGZIP() []byte {
-	file_google_protobuf_timestamp_proto_rawDescOnce.Do(func() {
-		file_google_protobuf_timestamp_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_timestamp_proto_rawDescData)
-	})
-	return file_google_protobuf_timestamp_proto_rawDescData
-}
-
-var file_google_protobuf_timestamp_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_google_protobuf_timestamp_proto_goTypes = []interface{}{
-	(*Timestamp)(nil), // 0: google.protobuf.Timestamp
-}
-var file_google_protobuf_timestamp_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
-}
-
-func init() { file_google_protobuf_timestamp_proto_init() }
-func file_google_protobuf_timestamp_proto_init() {
-	if File_google_protobuf_timestamp_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_google_protobuf_timestamp_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Timestamp); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_google_protobuf_timestamp_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   1,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_google_protobuf_timestamp_proto_goTypes,
-		DependencyIndexes: file_google_protobuf_timestamp_proto_depIdxs,
-		MessageInfos:      file_google_protobuf_timestamp_proto_msgTypes,
-	}.Build()
-	File_google_protobuf_timestamp_proto = out.File
-	file_google_protobuf_timestamp_proto_rawDesc = nil
-	file_google_protobuf_timestamp_proto_goTypes = nil
-	file_google_protobuf_timestamp_proto_depIdxs = nil
-}
diff --git a/vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go b/vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go
deleted file mode 100644
index 5c5ec2f..0000000
--- a/vendor/google.golang.org/protobuf/types/known/wrapperspb/wrappers.pb.go
+++ /dev/null
@@ -1,714 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Wrappers for primitive (non-message) types. These types are useful
-// for embedding primitives in the `google.protobuf.Any` type and for places
-// where we need to distinguish between the absence of a primitive
-// typed field and its default value.
-//
-// These wrappers have no meaningful use within repeated fields as they lack
-// the ability to detect presence on individual elements.
-// These wrappers have no meaningful use within a map or a oneof since
-// individual entries of a map or fields of a oneof can already detect presence.
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/wrappers.proto
-
-package wrapperspb
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	reflect "reflect"
-	sync "sync"
-)
-
-// Wrapper message for `double`.
-//
-// The JSON representation for `DoubleValue` is JSON number.
-type DoubleValue struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The double value.
-	Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *DoubleValue) Reset() {
-	*x = DoubleValue{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_wrappers_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DoubleValue) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DoubleValue) ProtoMessage() {}
-
-func (x *DoubleValue) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_wrappers_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DoubleValue.ProtoReflect.Descriptor instead.
-func (*DoubleValue) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *DoubleValue) GetValue() float64 {
-	if x != nil {
-		return x.Value
-	}
-	return 0
-}
-
-// Wrapper message for `float`.
-//
-// The JSON representation for `FloatValue` is JSON number.
-type FloatValue struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The float value.
-	Value float32 `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *FloatValue) Reset() {
-	*x = FloatValue{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_wrappers_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *FloatValue) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*FloatValue) ProtoMessage() {}
-
-func (x *FloatValue) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_wrappers_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use FloatValue.ProtoReflect.Descriptor instead.
-func (*FloatValue) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *FloatValue) GetValue() float32 {
-	if x != nil {
-		return x.Value
-	}
-	return 0
-}
-
-// Wrapper message for `int64`.
-//
-// The JSON representation for `Int64Value` is JSON string.
-type Int64Value struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The int64 value.
-	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *Int64Value) Reset() {
-	*x = Int64Value{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_wrappers_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Int64Value) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Int64Value) ProtoMessage() {}
-
-func (x *Int64Value) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_wrappers_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Int64Value.ProtoReflect.Descriptor instead.
-func (*Int64Value) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *Int64Value) GetValue() int64 {
-	if x != nil {
-		return x.Value
-	}
-	return 0
-}
-
-// Wrapper message for `uint64`.
-//
-// The JSON representation for `UInt64Value` is JSON string.
-type UInt64Value struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The uint64 value.
-	Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *UInt64Value) Reset() {
-	*x = UInt64Value{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_wrappers_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *UInt64Value) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*UInt64Value) ProtoMessage() {}
-
-func (x *UInt64Value) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_wrappers_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use UInt64Value.ProtoReflect.Descriptor instead.
-func (*UInt64Value) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{3}
-}
-
-func (x *UInt64Value) GetValue() uint64 {
-	if x != nil {
-		return x.Value
-	}
-	return 0
-}
-
-// Wrapper message for `int32`.
-//
-// The JSON representation for `Int32Value` is JSON number.
-type Int32Value struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The int32 value.
-	Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *Int32Value) Reset() {
-	*x = Int32Value{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_wrappers_proto_msgTypes[4]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Int32Value) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Int32Value) ProtoMessage() {}
-
-func (x *Int32Value) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_wrappers_proto_msgTypes[4]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Int32Value.ProtoReflect.Descriptor instead.
-func (*Int32Value) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *Int32Value) GetValue() int32 {
-	if x != nil {
-		return x.Value
-	}
-	return 0
-}
-
-// Wrapper message for `uint32`.
-//
-// The JSON representation for `UInt32Value` is JSON number.
-type UInt32Value struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The uint32 value.
-	Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *UInt32Value) Reset() {
-	*x = UInt32Value{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_wrappers_proto_msgTypes[5]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *UInt32Value) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*UInt32Value) ProtoMessage() {}
-
-func (x *UInt32Value) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_wrappers_proto_msgTypes[5]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use UInt32Value.ProtoReflect.Descriptor instead.
-func (*UInt32Value) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{5}
-}
-
-func (x *UInt32Value) GetValue() uint32 {
-	if x != nil {
-		return x.Value
-	}
-	return 0
-}
-
-// Wrapper message for `bool`.
-//
-// The JSON representation for `BoolValue` is JSON `true` and `false`.
-type BoolValue struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The bool value.
-	Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *BoolValue) Reset() {
-	*x = BoolValue{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_wrappers_proto_msgTypes[6]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *BoolValue) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*BoolValue) ProtoMessage() {}
-
-func (x *BoolValue) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_wrappers_proto_msgTypes[6]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use BoolValue.ProtoReflect.Descriptor instead.
-func (*BoolValue) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{6}
-}
-
-func (x *BoolValue) GetValue() bool {
-	if x != nil {
-		return x.Value
-	}
-	return false
-}
-
-// Wrapper message for `string`.
-//
-// The JSON representation for `StringValue` is JSON string.
-type StringValue struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The string value.
-	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *StringValue) Reset() {
-	*x = StringValue{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_wrappers_proto_msgTypes[7]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *StringValue) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*StringValue) ProtoMessage() {}
-
-func (x *StringValue) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_wrappers_proto_msgTypes[7]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use StringValue.ProtoReflect.Descriptor instead.
-func (*StringValue) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{7}
-}
-
-func (x *StringValue) GetValue() string {
-	if x != nil {
-		return x.Value
-	}
-	return ""
-}
-
-// Wrapper message for `bytes`.
-//
-// The JSON representation for `BytesValue` is JSON string.
-type BytesValue struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The bytes value.
-	Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (x *BytesValue) Reset() {
-	*x = BytesValue{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_wrappers_proto_msgTypes[8]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *BytesValue) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*BytesValue) ProtoMessage() {}
-
-func (x *BytesValue) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_wrappers_proto_msgTypes[8]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use BytesValue.ProtoReflect.Descriptor instead.
-func (*BytesValue) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_wrappers_proto_rawDescGZIP(), []int{8}
-}
-
-func (x *BytesValue) GetValue() []byte {
-	if x != nil {
-		return x.Value
-	}
-	return nil
-}
-
-var File_google_protobuf_wrappers_proto protoreflect.FileDescriptor
-
-var file_google_protobuf_wrappers_proto_rawDesc = []byte{
-	0x0a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x22, 0x23, 0x0a, 0x0b, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
-	0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52,
-	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x22, 0x0a, 0x0a, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x56,
-	0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x02, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x22, 0x0a, 0x0a, 0x49, 0x6e,
-	0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
-	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x23,
-	0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a,
-	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61,
-	0x6c, 0x75, 0x65, 0x22, 0x22, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75,
-	0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05,
-	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x23, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x33,
-	0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x21, 0x0a, 0x09,
-	0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
-	0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22,
-	0x23, 0x0a, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14,
-	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
-	0x61, 0x6c, 0x75, 0x65, 0x22, 0x22, 0x0a, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c,
-	0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x7c, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42,
-	0x0d, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01,
-	0x5a, 0x2a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
-	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
-	0x70, 0x65, 0x73, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0xf8, 0x01, 0x01, 0xa2,
-	0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50,
-	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77,
-	0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_google_protobuf_wrappers_proto_rawDescOnce sync.Once
-	file_google_protobuf_wrappers_proto_rawDescData = file_google_protobuf_wrappers_proto_rawDesc
-)
-
-func file_google_protobuf_wrappers_proto_rawDescGZIP() []byte {
-	file_google_protobuf_wrappers_proto_rawDescOnce.Do(func() {
-		file_google_protobuf_wrappers_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_wrappers_proto_rawDescData)
-	})
-	return file_google_protobuf_wrappers_proto_rawDescData
-}
-
-var file_google_protobuf_wrappers_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
-var file_google_protobuf_wrappers_proto_goTypes = []interface{}{
-	(*DoubleValue)(nil), // 0: google.protobuf.DoubleValue
-	(*FloatValue)(nil),  // 1: google.protobuf.FloatValue
-	(*Int64Value)(nil),  // 2: google.protobuf.Int64Value
-	(*UInt64Value)(nil), // 3: google.protobuf.UInt64Value
-	(*Int32Value)(nil),  // 4: google.protobuf.Int32Value
-	(*UInt32Value)(nil), // 5: google.protobuf.UInt32Value
-	(*BoolValue)(nil),   // 6: google.protobuf.BoolValue
-	(*StringValue)(nil), // 7: google.protobuf.StringValue
-	(*BytesValue)(nil),  // 8: google.protobuf.BytesValue
-}
-var file_google_protobuf_wrappers_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
-}
-
-func init() { file_google_protobuf_wrappers_proto_init() }
-func file_google_protobuf_wrappers_proto_init() {
-	if File_google_protobuf_wrappers_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_google_protobuf_wrappers_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DoubleValue); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_wrappers_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*FloatValue); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_wrappers_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Int64Value); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_wrappers_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*UInt64Value); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_wrappers_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Int32Value); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_wrappers_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*UInt32Value); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_wrappers_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*BoolValue); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_wrappers_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*StringValue); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_wrappers_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*BytesValue); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_google_protobuf_wrappers_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   9,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_google_protobuf_wrappers_proto_goTypes,
-		DependencyIndexes: file_google_protobuf_wrappers_proto_depIdxs,
-		MessageInfos:      file_google_protobuf_wrappers_proto_msgTypes,
-	}.Build()
-	File_google_protobuf_wrappers_proto = out.File
-	file_google_protobuf_wrappers_proto_rawDesc = nil
-	file_google_protobuf_wrappers_proto_goTypes = nil
-	file_google_protobuf_wrappers_proto_depIdxs = nil
-}
diff --git a/vendor/google.golang.org/protobuf/types/pluginpb/plugin.pb.go b/vendor/google.golang.org/protobuf/types/pluginpb/plugin.pb.go
deleted file mode 100644
index 43ef7cb..0000000
--- a/vendor/google.golang.org/protobuf/types/pluginpb/plugin.pb.go
+++ /dev/null
@@ -1,636 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Author: kenton@google.com (Kenton Varda)
-//
-// WARNING:  The plugin interface is currently EXPERIMENTAL and is subject to
-//   change.
-//
-// protoc (aka the Protocol Compiler) can be extended via plugins.  A plugin is
-// just a program that reads a CodeGeneratorRequest from stdin and writes a
-// CodeGeneratorResponse to stdout.
-//
-// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead
-// of dealing with the raw protocol defined here.
-//
-// A plugin executable needs only to be placed somewhere in the path.  The
-// plugin should be named "protoc-gen-$NAME", and will then be used when the
-// flag "--${NAME}_out" is passed to protoc.
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: google/protobuf/compiler/plugin.proto
-
-package pluginpb
-
-import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
-	sync "sync"
-)
-
-// Sync with code_generator.h.
-type CodeGeneratorResponse_Feature int32
-
-const (
-	CodeGeneratorResponse_FEATURE_NONE            CodeGeneratorResponse_Feature = 0
-	CodeGeneratorResponse_FEATURE_PROTO3_OPTIONAL CodeGeneratorResponse_Feature = 1
-)
-
-// Enum value maps for CodeGeneratorResponse_Feature.
-var (
-	CodeGeneratorResponse_Feature_name = map[int32]string{
-		0: "FEATURE_NONE",
-		1: "FEATURE_PROTO3_OPTIONAL",
-	}
-	CodeGeneratorResponse_Feature_value = map[string]int32{
-		"FEATURE_NONE":            0,
-		"FEATURE_PROTO3_OPTIONAL": 1,
-	}
-)
-
-func (x CodeGeneratorResponse_Feature) Enum() *CodeGeneratorResponse_Feature {
-	p := new(CodeGeneratorResponse_Feature)
-	*p = x
-	return p
-}
-
-func (x CodeGeneratorResponse_Feature) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (CodeGeneratorResponse_Feature) Descriptor() protoreflect.EnumDescriptor {
-	return file_google_protobuf_compiler_plugin_proto_enumTypes[0].Descriptor()
-}
-
-func (CodeGeneratorResponse_Feature) Type() protoreflect.EnumType {
-	return &file_google_protobuf_compiler_plugin_proto_enumTypes[0]
-}
-
-func (x CodeGeneratorResponse_Feature) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *CodeGeneratorResponse_Feature) UnmarshalJSON(b []byte) error {
-	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
-	if err != nil {
-		return err
-	}
-	*x = CodeGeneratorResponse_Feature(num)
-	return nil
-}
-
-// Deprecated: Use CodeGeneratorResponse_Feature.Descriptor instead.
-func (CodeGeneratorResponse_Feature) EnumDescriptor() ([]byte, []int) {
-	return file_google_protobuf_compiler_plugin_proto_rawDescGZIP(), []int{2, 0}
-}
-
-// The version number of protocol compiler.
-type Version struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Major *int32 `protobuf:"varint,1,opt,name=major" json:"major,omitempty"`
-	Minor *int32 `protobuf:"varint,2,opt,name=minor" json:"minor,omitempty"`
-	Patch *int32 `protobuf:"varint,3,opt,name=patch" json:"patch,omitempty"`
-	// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
-	// be empty for mainline stable releases.
-	Suffix *string `protobuf:"bytes,4,opt,name=suffix" json:"suffix,omitempty"`
-}
-
-func (x *Version) Reset() {
-	*x = Version{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *Version) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*Version) ProtoMessage() {}
-
-func (x *Version) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use Version.ProtoReflect.Descriptor instead.
-func (*Version) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_compiler_plugin_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *Version) GetMajor() int32 {
-	if x != nil && x.Major != nil {
-		return *x.Major
-	}
-	return 0
-}
-
-func (x *Version) GetMinor() int32 {
-	if x != nil && x.Minor != nil {
-		return *x.Minor
-	}
-	return 0
-}
-
-func (x *Version) GetPatch() int32 {
-	if x != nil && x.Patch != nil {
-		return *x.Patch
-	}
-	return 0
-}
-
-func (x *Version) GetSuffix() string {
-	if x != nil && x.Suffix != nil {
-		return *x.Suffix
-	}
-	return ""
-}
-
-// An encoded CodeGeneratorRequest is written to the plugin's stdin.
-type CodeGeneratorRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The .proto files that were explicitly listed on the command-line.  The
-	// code generator should generate code only for these files.  Each file's
-	// descriptor will be included in proto_file, below.
-	FileToGenerate []string `protobuf:"bytes,1,rep,name=file_to_generate,json=fileToGenerate" json:"file_to_generate,omitempty"`
-	// The generator parameter passed on the command-line.
-	Parameter *string `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"`
-	// FileDescriptorProtos for all files in files_to_generate and everything
-	// they import.  The files will appear in topological order, so each file
-	// appears before any file that imports it.
-	//
-	// protoc guarantees that all proto_files will be written after
-	// the fields above, even though this is not technically guaranteed by the
-	// protobuf wire format.  This theoretically could allow a plugin to stream
-	// in the FileDescriptorProtos and handle them one by one rather than read
-	// the entire set into memory at once.  However, as of this writing, this
-	// is not similarly optimized on protoc's end -- it will store all fields in
-	// memory at once before sending them to the plugin.
-	//
-	// Type names of fields and extensions in the FileDescriptorProto are always
-	// fully qualified.
-	ProtoFile []*descriptorpb.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file,json=protoFile" json:"proto_file,omitempty"`
-	// The version number of protocol compiler.
-	CompilerVersion *Version `protobuf:"bytes,3,opt,name=compiler_version,json=compilerVersion" json:"compiler_version,omitempty"`
-}
-
-func (x *CodeGeneratorRequest) Reset() {
-	*x = CodeGeneratorRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *CodeGeneratorRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*CodeGeneratorRequest) ProtoMessage() {}
-
-func (x *CodeGeneratorRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use CodeGeneratorRequest.ProtoReflect.Descriptor instead.
-func (*CodeGeneratorRequest) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_compiler_plugin_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *CodeGeneratorRequest) GetFileToGenerate() []string {
-	if x != nil {
-		return x.FileToGenerate
-	}
-	return nil
-}
-
-func (x *CodeGeneratorRequest) GetParameter() string {
-	if x != nil && x.Parameter != nil {
-		return *x.Parameter
-	}
-	return ""
-}
-
-func (x *CodeGeneratorRequest) GetProtoFile() []*descriptorpb.FileDescriptorProto {
-	if x != nil {
-		return x.ProtoFile
-	}
-	return nil
-}
-
-func (x *CodeGeneratorRequest) GetCompilerVersion() *Version {
-	if x != nil {
-		return x.CompilerVersion
-	}
-	return nil
-}
-
-// The plugin writes an encoded CodeGeneratorResponse to stdout.
-type CodeGeneratorResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// Error message.  If non-empty, code generation failed.  The plugin process
-	// should exit with status code zero even if it reports an error in this way.
-	//
-	// This should be used to indicate errors in .proto files which prevent the
-	// code generator from generating correct code.  Errors which indicate a
-	// problem in protoc itself -- such as the input CodeGeneratorRequest being
-	// unparseable -- should be reported by writing a message to stderr and
-	// exiting with a non-zero status code.
-	Error *string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
-	// A bitmask of supported features that the code generator supports.
-	// This is a bitwise "or" of values from the Feature enum.
-	SupportedFeatures *uint64                       `protobuf:"varint,2,opt,name=supported_features,json=supportedFeatures" json:"supported_features,omitempty"`
-	File              []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"`
-}
-
-func (x *CodeGeneratorResponse) Reset() {
-	*x = CodeGeneratorResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *CodeGeneratorResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*CodeGeneratorResponse) ProtoMessage() {}
-
-func (x *CodeGeneratorResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use CodeGeneratorResponse.ProtoReflect.Descriptor instead.
-func (*CodeGeneratorResponse) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_compiler_plugin_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *CodeGeneratorResponse) GetError() string {
-	if x != nil && x.Error != nil {
-		return *x.Error
-	}
-	return ""
-}
-
-func (x *CodeGeneratorResponse) GetSupportedFeatures() uint64 {
-	if x != nil && x.SupportedFeatures != nil {
-		return *x.SupportedFeatures
-	}
-	return 0
-}
-
-func (x *CodeGeneratorResponse) GetFile() []*CodeGeneratorResponse_File {
-	if x != nil {
-		return x.File
-	}
-	return nil
-}
-
-// Represents a single generated file.
-type CodeGeneratorResponse_File struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// The file name, relative to the output directory.  The name must not
-	// contain "." or ".." components and must be relative, not be absolute (so,
-	// the file cannot lie outside the output directory).  "/" must be used as
-	// the path separator, not "\".
-	//
-	// If the name is omitted, the content will be appended to the previous
-	// file.  This allows the generator to break large files into small chunks,
-	// and allows the generated text to be streamed back to protoc so that large
-	// files need not reside completely in memory at one time.  Note that as of
-	// this writing protoc does not optimize for this -- it will read the entire
-	// CodeGeneratorResponse before writing files to disk.
-	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
-	// If non-empty, indicates that the named file should already exist, and the
-	// content here is to be inserted into that file at a defined insertion
-	// point.  This feature allows a code generator to extend the output
-	// produced by another code generator.  The original generator may provide
-	// insertion points by placing special annotations in the file that look
-	// like:
-	//   @@protoc_insertion_point(NAME)
-	// The annotation can have arbitrary text before and after it on the line,
-	// which allows it to be placed in a comment.  NAME should be replaced with
-	// an identifier naming the point -- this is what other generators will use
-	// as the insertion_point.  Code inserted at this point will be placed
-	// immediately above the line containing the insertion point (thus multiple
-	// insertions to the same point will come out in the order they were added).
-	// The double-@ is intended to make it unlikely that the generated code
-	// could contain things that look like insertion points by accident.
-	//
-	// For example, the C++ code generator places the following line in the
-	// .pb.h files that it generates:
-	//   // @@protoc_insertion_point(namespace_scope)
-	// This line appears within the scope of the file's package namespace, but
-	// outside of any particular class.  Another plugin can then specify the
-	// insertion_point "namespace_scope" to generate additional classes or
-	// other declarations that should be placed in this scope.
-	//
-	// Note that if the line containing the insertion point begins with
-	// whitespace, the same whitespace will be added to every line of the
-	// inserted text.  This is useful for languages like Python, where
-	// indentation matters.  In these languages, the insertion point comment
-	// should be indented the same amount as any inserted code will need to be
-	// in order to work correctly in that context.
-	//
-	// The code generator that generates the initial file and the one which
-	// inserts into it must both run as part of a single invocation of protoc.
-	// Code generators are executed in the order in which they appear on the
-	// command line.
-	//
-	// If |insertion_point| is present, |name| must also be present.
-	InsertionPoint *string `protobuf:"bytes,2,opt,name=insertion_point,json=insertionPoint" json:"insertion_point,omitempty"`
-	// The file contents.
-	Content *string `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"`
-}
-
-func (x *CodeGeneratorResponse_File) Reset() {
-	*x = CodeGeneratorResponse_File{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *CodeGeneratorResponse_File) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*CodeGeneratorResponse_File) ProtoMessage() {}
-
-func (x *CodeGeneratorResponse_File) ProtoReflect() protoreflect.Message {
-	mi := &file_google_protobuf_compiler_plugin_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use CodeGeneratorResponse_File.ProtoReflect.Descriptor instead.
-func (*CodeGeneratorResponse_File) Descriptor() ([]byte, []int) {
-	return file_google_protobuf_compiler_plugin_proto_rawDescGZIP(), []int{2, 0}
-}
-
-func (x *CodeGeneratorResponse_File) GetName() string {
-	if x != nil && x.Name != nil {
-		return *x.Name
-	}
-	return ""
-}
-
-func (x *CodeGeneratorResponse_File) GetInsertionPoint() string {
-	if x != nil && x.InsertionPoint != nil {
-		return *x.InsertionPoint
-	}
-	return ""
-}
-
-func (x *CodeGeneratorResponse_File) GetContent() string {
-	if x != nil && x.Content != nil {
-		return *x.Content
-	}
-	return ""
-}
-
-var File_google_protobuf_compiler_plugin_proto protoreflect.FileDescriptor
-
-var file_google_protobuf_compiler_plugin_proto_rawDesc = []byte{
-	0x0a, 0x25, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69,
-	0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
-	0x72, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
-	0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x22, 0x63, 0x0a, 0x07, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14,
-	0x0a, 0x05, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d,
-	0x61, 0x6a, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61,
-	0x74, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68,
-	0x12, 0x16, 0x0a, 0x06, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x06, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x22, 0xf1, 0x01, 0x0a, 0x14, 0x43, 0x6f, 0x64,
-	0x65, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x12, 0x28, 0x0a, 0x10, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x67, 0x65, 0x6e,
-	0x65, 0x72, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x66, 0x69, 0x6c,
-	0x65, 0x54, 0x6f, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70,
-	0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
-	0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x12, 0x43, 0x0a, 0x0a, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
-	0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72,
-	0x6f, 0x74, 0x6f, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x4c,
-	0x0a, 0x10, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69,
-	0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
-	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
-	0x6c, 0x65, 0x72, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x63, 0x6f, 0x6d,
-	0x70, 0x69, 0x6c, 0x65, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xbf, 0x02, 0x0a,
-	0x15, 0x43, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x2d, 0x0a, 0x12,
-	0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72,
-	0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72,
-	0x74, 0x65, 0x64, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x04, 0x66,
-	0x69, 0x6c, 0x65, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
-	0x69, 0x6c, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x64, 0x65, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
-	0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x52,
-	0x04, 0x66, 0x69, 0x6c, 0x65, 0x1a, 0x5d, 0x0a, 0x04, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x12, 0x0a,
-	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
-	0x65, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70,
-	0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x69, 0x6e, 0x73, 0x65,
-	0x72, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f,
-	0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6e,
-	0x74, 0x65, 0x6e, 0x74, 0x22, 0x38, 0x0a, 0x07, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12,
-	0x10, 0x0a, 0x0c, 0x46, 0x45, 0x41, 0x54, 0x55, 0x52, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10,
-	0x00, 0x12, 0x1b, 0x0a, 0x17, 0x46, 0x45, 0x41, 0x54, 0x55, 0x52, 0x45, 0x5f, 0x50, 0x52, 0x4f,
-	0x54, 0x4f, 0x33, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x41, 0x4c, 0x10, 0x01, 0x42, 0x67,
-	0x0a, 0x1c, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x42, 0x0c,
-	0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x5a, 0x39, 0x67, 0x69,
-	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2f,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2d,
-	0x67, 0x65, 0x6e, 0x2d, 0x67, 0x6f, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x3b, 0x70, 0x6c,
-	0x75, 0x67, 0x69, 0x6e, 0x5f, 0x67, 0x6f,
-}
-
-var (
-	file_google_protobuf_compiler_plugin_proto_rawDescOnce sync.Once
-	file_google_protobuf_compiler_plugin_proto_rawDescData = file_google_protobuf_compiler_plugin_proto_rawDesc
-)
-
-func file_google_protobuf_compiler_plugin_proto_rawDescGZIP() []byte {
-	file_google_protobuf_compiler_plugin_proto_rawDescOnce.Do(func() {
-		file_google_protobuf_compiler_plugin_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_compiler_plugin_proto_rawDescData)
-	})
-	return file_google_protobuf_compiler_plugin_proto_rawDescData
-}
-
-var file_google_protobuf_compiler_plugin_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_google_protobuf_compiler_plugin_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
-var file_google_protobuf_compiler_plugin_proto_goTypes = []interface{}{
-	(CodeGeneratorResponse_Feature)(0),       // 0: google.protobuf.compiler.CodeGeneratorResponse.Feature
-	(*Version)(nil),                          // 1: google.protobuf.compiler.Version
-	(*CodeGeneratorRequest)(nil),             // 2: google.protobuf.compiler.CodeGeneratorRequest
-	(*CodeGeneratorResponse)(nil),            // 3: google.protobuf.compiler.CodeGeneratorResponse
-	(*CodeGeneratorResponse_File)(nil),       // 4: google.protobuf.compiler.CodeGeneratorResponse.File
-	(*descriptorpb.FileDescriptorProto)(nil), // 5: google.protobuf.FileDescriptorProto
-}
-var file_google_protobuf_compiler_plugin_proto_depIdxs = []int32{
-	5, // 0: google.protobuf.compiler.CodeGeneratorRequest.proto_file:type_name -> google.protobuf.FileDescriptorProto
-	1, // 1: google.protobuf.compiler.CodeGeneratorRequest.compiler_version:type_name -> google.protobuf.compiler.Version
-	4, // 2: google.protobuf.compiler.CodeGeneratorResponse.file:type_name -> google.protobuf.compiler.CodeGeneratorResponse.File
-	3, // [3:3] is the sub-list for method output_type
-	3, // [3:3] is the sub-list for method input_type
-	3, // [3:3] is the sub-list for extension type_name
-	3, // [3:3] is the sub-list for extension extendee
-	0, // [0:3] is the sub-list for field type_name
-}
-
-func init() { file_google_protobuf_compiler_plugin_proto_init() }
-func file_google_protobuf_compiler_plugin_proto_init() {
-	if File_google_protobuf_compiler_plugin_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_google_protobuf_compiler_plugin_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Version); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_compiler_plugin_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*CodeGeneratorRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_compiler_plugin_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*CodeGeneratorResponse); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_google_protobuf_compiler_plugin_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*CodeGeneratorResponse_File); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_google_protobuf_compiler_plugin_proto_rawDesc,
-			NumEnums:      1,
-			NumMessages:   4,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_google_protobuf_compiler_plugin_proto_goTypes,
-		DependencyIndexes: file_google_protobuf_compiler_plugin_proto_depIdxs,
-		EnumInfos:         file_google_protobuf_compiler_plugin_proto_enumTypes,
-		MessageInfos:      file_google_protobuf_compiler_plugin_proto_msgTypes,
-	}.Build()
-	File_google_protobuf_compiler_plugin_proto = out.File
-	file_google_protobuf_compiler_plugin_proto_rawDesc = nil
-	file_google_protobuf_compiler_plugin_proto_goTypes = nil
-	file_google_protobuf_compiler_plugin_proto_depIdxs = nil
-}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index edf60e8..93a59a8 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -34,7 +34,7 @@
 github.com/gogo/protobuf/gogoproto
 github.com/gogo/protobuf/proto
 github.com/gogo/protobuf/protoc-gen-gogo/descriptor
-# github.com/golang/protobuf v1.4.2
+# github.com/golang/protobuf v1.3.2
 github.com/golang/protobuf/jsonpb
 github.com/golang/protobuf/proto
 github.com/golang/protobuf/protoc-gen-go/descriptor
@@ -45,6 +45,7 @@
 github.com/golang/protobuf/ptypes/any
 github.com/golang/protobuf/ptypes/duration
 github.com/golang/protobuf/ptypes/empty
+github.com/golang/protobuf/ptypes/struct
 github.com/golang/protobuf/ptypes/timestamp
 github.com/golang/protobuf/ptypes/wrappers
 # github.com/golang/snappy v0.0.1
@@ -331,44 +332,6 @@
 google.golang.org/grpc/stats
 google.golang.org/grpc/status
 google.golang.org/grpc/tap
-# google.golang.org/protobuf v1.23.0
-google.golang.org/protobuf/encoding/protojson
-google.golang.org/protobuf/encoding/prototext
-google.golang.org/protobuf/encoding/protowire
-google.golang.org/protobuf/internal/descfmt
-google.golang.org/protobuf/internal/descopts
-google.golang.org/protobuf/internal/detectknown
-google.golang.org/protobuf/internal/detrand
-google.golang.org/protobuf/internal/encoding/defval
-google.golang.org/protobuf/internal/encoding/json
-google.golang.org/protobuf/internal/encoding/messageset
-google.golang.org/protobuf/internal/encoding/tag
-google.golang.org/protobuf/internal/encoding/text
-google.golang.org/protobuf/internal/errors
-google.golang.org/protobuf/internal/fieldnum
-google.golang.org/protobuf/internal/fieldsort
-google.golang.org/protobuf/internal/filedesc
-google.golang.org/protobuf/internal/filetype
-google.golang.org/protobuf/internal/flags
-google.golang.org/protobuf/internal/genname
-google.golang.org/protobuf/internal/impl
-google.golang.org/protobuf/internal/mapsort
-google.golang.org/protobuf/internal/pragma
-google.golang.org/protobuf/internal/set
-google.golang.org/protobuf/internal/strs
-google.golang.org/protobuf/internal/version
-google.golang.org/protobuf/proto
-google.golang.org/protobuf/reflect/protoreflect
-google.golang.org/protobuf/reflect/protoregistry
-google.golang.org/protobuf/runtime/protoiface
-google.golang.org/protobuf/runtime/protoimpl
-google.golang.org/protobuf/types/descriptorpb
-google.golang.org/protobuf/types/known/anypb
-google.golang.org/protobuf/types/known/durationpb
-google.golang.org/protobuf/types/known/emptypb
-google.golang.org/protobuf/types/known/timestamppb
-google.golang.org/protobuf/types/known/wrapperspb
-google.golang.org/protobuf/types/pluginpb
 # gopkg.in/jcmturner/aescts.v1 v1.0.1
 gopkg.in/jcmturner/aescts.v1
 # gopkg.in/jcmturner/dnsutils.v1 v1.0.1