custom_tag.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: envoy/type/tracing/v2/custom_tag.proto

package envoy_type_tracing_v2

import (
	fmt "fmt"
	_ "github.com/cncf/udpa/go/udpa/annotations"
	v2 "github.com/datawire/ambassador/pkg/api/envoy/type/metadata/v2"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

// Describes custom tags for the active span.
// [#next-free-field: 6]
type CustomTag struct {
	// Used to populate the tag name.
	Tag string `protobuf:"bytes,1,opt,name=tag,proto3" json:"tag,omitempty"`
	// Used to specify what kind of custom tag.
	//
	// Types that are valid to be assigned to Type:
	//	*CustomTag_Literal_
	//	*CustomTag_Environment_
	//	*CustomTag_RequestHeader
	//	*CustomTag_Metadata_
	Type                 isCustomTag_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *CustomTag) Reset()         { *m = CustomTag{} }
func (m *CustomTag) String() string { return proto.CompactTextString(m) }
func (*CustomTag) ProtoMessage()    {}
func (*CustomTag) Descriptor() ([]byte, []int) {
	return fileDescriptor_d6b7ba7857eb6848, []int{0}
}
func (m *CustomTag) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CustomTag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CustomTag.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CustomTag) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CustomTag.Merge(m, src)
}
func (m *CustomTag) XXX_Size() int {
	return m.Size()
}
func (m *CustomTag) XXX_DiscardUnknown() {
	xxx_messageInfo_CustomTag.DiscardUnknown(m)
}

var xxx_messageInfo_CustomTag proto.InternalMessageInfo

type isCustomTag_Type interface {
	isCustomTag_Type()
	MarshalTo([]byte) (int, error)
	Size() int
}

type CustomTag_Literal_ struct {
	Literal *CustomTag_Literal `protobuf:"bytes,2,opt,name=literal,proto3,oneof" json:"literal,omitempty"`
}
type CustomTag_Environment_ struct {
	Environment *CustomTag_Environment `protobuf:"bytes,3,opt,name=environment,proto3,oneof" json:"environment,omitempty"`
}
type CustomTag_RequestHeader struct {
	RequestHeader *CustomTag_Header `protobuf:"bytes,4,opt,name=request_header,json=requestHeader,proto3,oneof" json:"request_header,omitempty"`
}
type CustomTag_Metadata_ struct {
	Metadata *CustomTag_Metadata `protobuf:"bytes,5,opt,name=metadata,proto3,oneof" json:"metadata,omitempty"`
}

func (*CustomTag_Literal_) isCustomTag_Type()      {}
func (*CustomTag_Environment_) isCustomTag_Type()  {}
func (*CustomTag_RequestHeader) isCustomTag_Type() {}
func (*CustomTag_Metadata_) isCustomTag_Type()     {}

func (m *CustomTag) GetType() isCustomTag_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *CustomTag) GetTag() string {
	if m != nil {
		return m.Tag
	}
	return ""
}

func (m *CustomTag) GetLiteral() *CustomTag_Literal {
	if x, ok := m.GetType().(*CustomTag_Literal_); ok {
		return x.Literal
	}
	return nil
}

func (m *CustomTag) GetEnvironment() *CustomTag_Environment {
	if x, ok := m.GetType().(*CustomTag_Environment_); ok {
		return x.Environment
	}
	return nil
}

func (m *CustomTag) GetRequestHeader() *CustomTag_Header {
	if x, ok := m.GetType().(*CustomTag_RequestHeader); ok {
		return x.RequestHeader
	}
	return nil
}

func (m *CustomTag) GetMetadata() *CustomTag_Metadata {
	if x, ok := m.GetType().(*CustomTag_Metadata_); ok {
		return x.Metadata
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CustomTag) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CustomTag_Literal_)(nil),
		(*CustomTag_Environment_)(nil),
		(*CustomTag_RequestHeader)(nil),
		(*CustomTag_Metadata_)(nil),
	}
}

// Literal type custom tag with static value for the tag value.
type CustomTag_Literal struct {
	// Static literal value to populate the tag 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 *CustomTag_Literal) Reset()         { *m = CustomTag_Literal{} }
func (m *CustomTag_Literal) String() string { return proto.CompactTextString(m) }
func (*CustomTag_Literal) ProtoMessage()    {}
func (*CustomTag_Literal) Descriptor() ([]byte, []int) {
	return fileDescriptor_d6b7ba7857eb6848, []int{0, 0}
}
func (m *CustomTag_Literal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CustomTag_Literal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CustomTag_Literal.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CustomTag_Literal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CustomTag_Literal.Merge(m, src)
}
func (m *CustomTag_Literal) XXX_Size() int {
	return m.Size()
}
func (m *CustomTag_Literal) XXX_DiscardUnknown() {
	xxx_messageInfo_CustomTag_Literal.DiscardUnknown(m)
}

var xxx_messageInfo_CustomTag_Literal proto.InternalMessageInfo

func (m *CustomTag_Literal) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

// Environment type custom tag with environment name and default value.
type CustomTag_Environment struct {
	// Environment variable name to obtain the value to populate the tag value.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// When the environment variable is not found,
	// the tag value will be populated with this default value if specified,
	// otherwise no tag will be populated.
	DefaultValue         string   `protobuf:"bytes,2,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CustomTag_Environment) Reset()         { *m = CustomTag_Environment{} }
func (m *CustomTag_Environment) String() string { return proto.CompactTextString(m) }
func (*CustomTag_Environment) ProtoMessage()    {}
func (*CustomTag_Environment) Descriptor() ([]byte, []int) {
	return fileDescriptor_d6b7ba7857eb6848, []int{0, 1}
}
func (m *CustomTag_Environment) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CustomTag_Environment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CustomTag_Environment.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CustomTag_Environment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CustomTag_Environment.Merge(m, src)
}
func (m *CustomTag_Environment) XXX_Size() int {
	return m.Size()
}
func (m *CustomTag_Environment) XXX_DiscardUnknown() {
	xxx_messageInfo_CustomTag_Environment.DiscardUnknown(m)
}

var xxx_messageInfo_CustomTag_Environment proto.InternalMessageInfo

func (m *CustomTag_Environment) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *CustomTag_Environment) GetDefaultValue() string {
	if m != nil {
		return m.DefaultValue
	}
	return ""
}

// Header type custom tag with header name and default value.
type CustomTag_Header struct {
	// Header name to obtain the value to populate the tag value.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// When the header does not exist,
	// the tag value will be populated with this default value if specified,
	// otherwise no tag will be populated.
	DefaultValue         string   `protobuf:"bytes,2,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CustomTag_Header) Reset()         { *m = CustomTag_Header{} }
func (m *CustomTag_Header) String() string { return proto.CompactTextString(m) }
func (*CustomTag_Header) ProtoMessage()    {}
func (*CustomTag_Header) Descriptor() ([]byte, []int) {
	return fileDescriptor_d6b7ba7857eb6848, []int{0, 2}
}
func (m *CustomTag_Header) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CustomTag_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CustomTag_Header.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CustomTag_Header) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CustomTag_Header.Merge(m, src)
}
func (m *CustomTag_Header) XXX_Size() int {
	return m.Size()
}
func (m *CustomTag_Header) XXX_DiscardUnknown() {
	xxx_messageInfo_CustomTag_Header.DiscardUnknown(m)
}

var xxx_messageInfo_CustomTag_Header proto.InternalMessageInfo

func (m *CustomTag_Header) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *CustomTag_Header) GetDefaultValue() string {
	if m != nil {
		return m.DefaultValue
	}
	return ""
}

// Metadata type custom tag using
// :ref:`MetadataKey <envoy_api_msg_type.metadata.v2.MetadataKey>` to retrieve the protobuf value
// from :ref:`Metadata <envoy_api_msg_core.Metadata>`, and populate the tag value with
// `the canonical JSON <https://developers.google.com/protocol-buffers/docs/proto3#json>`_
// representation of it.
type CustomTag_Metadata struct {
	// Specify what kind of metadata to obtain tag value from.
	Kind *v2.MetadataKind `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
	// Metadata key to define the path to retrieve the tag value.
	MetadataKey *v2.MetadataKey `protobuf:"bytes,2,opt,name=metadata_key,json=metadataKey,proto3" json:"metadata_key,omitempty"`
	// When no valid metadata is found,
	// the tag value would be populated with this default value if specified,
	// otherwise no tag would be populated.
	DefaultValue         string   `protobuf:"bytes,3,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CustomTag_Metadata) Reset()         { *m = CustomTag_Metadata{} }
func (m *CustomTag_Metadata) String() string { return proto.CompactTextString(m) }
func (*CustomTag_Metadata) ProtoMessage()    {}
func (*CustomTag_Metadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_d6b7ba7857eb6848, []int{0, 3}
}
func (m *CustomTag_Metadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CustomTag_Metadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CustomTag_Metadata.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CustomTag_Metadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CustomTag_Metadata.Merge(m, src)
}
func (m *CustomTag_Metadata) XXX_Size() int {
	return m.Size()
}
func (m *CustomTag_Metadata) XXX_DiscardUnknown() {
	xxx_messageInfo_CustomTag_Metadata.DiscardUnknown(m)
}

var xxx_messageInfo_CustomTag_Metadata proto.InternalMessageInfo

func (m *CustomTag_Metadata) GetKind() *v2.MetadataKind {
	if m != nil {
		return m.Kind
	}
	return nil
}

func (m *CustomTag_Metadata) GetMetadataKey() *v2.MetadataKey {
	if m != nil {
		return m.MetadataKey
	}
	return nil
}

func (m *CustomTag_Metadata) GetDefaultValue() string {
	if m != nil {
		return m.DefaultValue
	}
	return ""
}

func init() {
	proto.RegisterType((*CustomTag)(nil), "envoy.type.tracing.v2.CustomTag")
	proto.RegisterType((*CustomTag_Literal)(nil), "envoy.type.tracing.v2.CustomTag.Literal")
	proto.RegisterType((*CustomTag_Environment)(nil), "envoy.type.tracing.v2.CustomTag.Environment")
	proto.RegisterType((*CustomTag_Header)(nil), "envoy.type.tracing.v2.CustomTag.Header")
	proto.RegisterType((*CustomTag_Metadata)(nil), "envoy.type.tracing.v2.CustomTag.Metadata")
}

func init() {
	proto.RegisterFile("envoy/type/tracing/v2/custom_tag.proto", fileDescriptor_d6b7ba7857eb6848)
}

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

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

func (m *CustomTag) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomTag) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Type != nil {
		{
			size := m.Type.Size()
			i -= size
			if _, err := m.Type.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Tag) > 0 {
		i -= len(m.Tag)
		copy(dAtA[i:], m.Tag)
		i = encodeVarintCustomTag(dAtA, i, uint64(len(m.Tag)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CustomTag_Literal_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomTag_Literal_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Literal != nil {
		{
			size, err := m.Literal.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCustomTag(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *CustomTag_Environment_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomTag_Environment_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Environment != nil {
		{
			size, err := m.Environment.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCustomTag(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *CustomTag_RequestHeader) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomTag_RequestHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RequestHeader != nil {
		{
			size, err := m.RequestHeader.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCustomTag(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *CustomTag_Metadata_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomTag_Metadata_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCustomTag(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *CustomTag_Literal) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CustomTag_Literal) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomTag_Literal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintCustomTag(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CustomTag_Environment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomTag_Environment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.DefaultValue) > 0 {
		i -= len(m.DefaultValue)
		copy(dAtA[i:], m.DefaultValue)
		i = encodeVarintCustomTag(dAtA, i, uint64(len(m.DefaultValue)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCustomTag(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CustomTag_Header) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomTag_Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.DefaultValue) > 0 {
		i -= len(m.DefaultValue)
		copy(dAtA[i:], m.DefaultValue)
		i = encodeVarintCustomTag(dAtA, i, uint64(len(m.DefaultValue)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCustomTag(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CustomTag_Metadata) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomTag_Metadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.DefaultValue) > 0 {
		i -= len(m.DefaultValue)
		copy(dAtA[i:], m.DefaultValue)
		i = encodeVarintCustomTag(dAtA, i, uint64(len(m.DefaultValue)))
		i--
		dAtA[i] = 0x1a
	}
	if m.MetadataKey != nil {
		{
			size, err := m.MetadataKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCustomTag(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Kind != nil {
		{
			size, err := m.Kind.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCustomTag(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintCustomTag(dAtA []byte, offset int, v uint64) int {
	offset -= sovCustomTag(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *CustomTag) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Tag)
	if l > 0 {
		n += 1 + l + sovCustomTag(uint64(l))
	}
	if m.Type != nil {
		n += m.Type.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CustomTag_Literal_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Literal != nil {
		l = m.Literal.Size()
		n += 1 + l + sovCustomTag(uint64(l))
	}
	return n
}
func (m *CustomTag_Environment_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Environment != nil {
		l = m.Environment.Size()
		n += 1 + l + sovCustomTag(uint64(l))
	}
	return n
}
func (m *CustomTag_RequestHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestHeader != nil {
		l = m.RequestHeader.Size()
		n += 1 + l + sovCustomTag(uint64(l))
	}
	return n
}
func (m *CustomTag_Metadata_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovCustomTag(uint64(l))
	}
	return n
}
func (m *CustomTag_Literal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovCustomTag(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CustomTag_Environment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCustomTag(uint64(l))
	}
	l = len(m.DefaultValue)
	if l > 0 {
		n += 1 + l + sovCustomTag(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CustomTag_Header) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCustomTag(uint64(l))
	}
	l = len(m.DefaultValue)
	if l > 0 {
		n += 1 + l + sovCustomTag(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CustomTag_Metadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Kind != nil {
		l = m.Kind.Size()
		n += 1 + l + sovCustomTag(uint64(l))
	}
	if m.MetadataKey != nil {
		l = m.MetadataKey.Size()
		n += 1 + l + sovCustomTag(uint64(l))
	}
	l = len(m.DefaultValue)
	if l > 0 {
		n += 1 + l + sovCustomTag(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovCustomTag(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCustomTag(x uint64) (n int) {
	return sovCustomTag(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *CustomTag) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCustomTag
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CustomTag: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CustomTag: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tag = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Literal", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CustomTag_Literal{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Type = &CustomTag_Literal_{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Environment", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CustomTag_Environment{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Type = &CustomTag_Environment_{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestHeader", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CustomTag_Header{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Type = &CustomTag_RequestHeader{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CustomTag_Metadata{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Type = &CustomTag_Metadata_{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCustomTag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCustomTag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCustomTag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CustomTag_Literal) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCustomTag
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Literal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Literal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCustomTag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCustomTag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCustomTag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CustomTag_Environment) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCustomTag
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Environment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Environment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCustomTag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCustomTag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCustomTag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CustomTag_Header) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCustomTag
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Header: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCustomTag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCustomTag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCustomTag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CustomTag_Metadata) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCustomTag
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Metadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Metadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Kind == nil {
				m.Kind = &v2.MetadataKind{}
			}
			if err := m.Kind.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetadataKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MetadataKey == nil {
				m.MetadataKey = &v2.MetadataKey{}
			}
			if err := m.MetadataKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCustomTag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCustomTag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCustomTag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCustomTag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCustomTag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipCustomTag(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowCustomTag
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCustomTag
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthCustomTag
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupCustomTag
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthCustomTag
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthCustomTag        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCustomTag          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupCustomTag = fmt.Errorf("proto: unexpected end of group")
)