frostfs-api-go/object/grpc/service_frostfs.pb.go

// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.

package object

import (
	json "encoding/json"
	fmt "fmt"
	grpc "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
	grpc1 "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session/grpc"
	pool "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/util/pool"
	proto "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/util/proto"
	encoding "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/util/proto/encoding"
	easyproto "github.com/VictoriaMetrics/easyproto"
	jlexer "github.com/mailru/easyjson/jlexer"
	jwriter "github.com/mailru/easyjson/jwriter"
	strconv "strconv"
)

type GetRequest_Body struct {
	Address *grpc.Address `json:"address"`
	Raw     bool          `json:"raw"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetRequest_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*GetRequest_Body)(nil)
	_ json.Marshaler            = (*GetRequest_Body)(nil)
	_ json.Unmarshaler          = (*GetRequest_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Address)
	size += proto.BoolSize(2, x.Raw)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetRequest_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Address != nil {
		x.Address.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.Raw {
		mm.AppendBool(2, x.Raw)
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetRequest_Body")
		}
		switch fc.FieldNum {
		case 1: // Address
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Address")
			}
			x.Address = new(grpc.Address)
			if err := x.Address.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // Raw
			data, ok := fc.Bool()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Raw")
			}
			x.Raw = data
		}
	}
	return nil
}
func (x *GetRequest_Body) GetAddress() *grpc.Address {
	if x != nil {
		return x.Address
	}
	return nil
}
func (x *GetRequest_Body) SetAddress(v *grpc.Address) {
	x.Address = v
}
func (x *GetRequest_Body) GetRaw() bool {
	if x != nil {
		return x.Raw
	}
	return false
}
func (x *GetRequest_Body) SetRaw(v bool) {
	x.Raw = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetRequest_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetRequest_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Address != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"address\":"
			out.RawString(prefix)
			x.Address.MarshalEasyJSON(out)
		}
	}
	{
		if x.Raw {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"raw\":"
			out.RawString(prefix)
			out.Bool(x.Raw)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetRequest_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "address":
			{
				var f *grpc.Address
				f = new(grpc.Address)
				f.UnmarshalEasyJSON(in)
				x.Address = f
			}
		case "raw":
			{
				var f bool
				f = in.Bool()
				x.Raw = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type GetRequest struct {
	Body         *GetRequest_Body                 `json:"body"`
	MetaHeader   *grpc1.RequestMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.RequestVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetRequest)(nil)
	_ encoding.ProtoUnmarshaler = (*GetRequest)(nil)
	_ json.Marshaler            = (*GetRequest)(nil)
	_ json.Unmarshaler          = (*GetRequest)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetRequest) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *GetRequest) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *GetRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetRequest) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetRequest) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetRequest) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetRequest")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(GetRequest_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.RequestMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.RequestVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *GetRequest) GetBody() *GetRequest_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *GetRequest) SetBody(v *GetRequest_Body) {
	x.Body = v
}
func (x *GetRequest) GetMetaHeader() *grpc1.RequestMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *GetRequest) SetMetaHeader(v *grpc1.RequestMetaHeader) {
	x.MetaHeader = v
}
func (x *GetRequest) GetVerifyHeader() *grpc1.RequestVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *GetRequest) SetVerifyHeader(v *grpc1.RequestVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetRequest) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *GetRequest_Body
				f = new(GetRequest_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.RequestMetaHeader
				f = new(grpc1.RequestMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.RequestVerificationHeader
				f = new(grpc1.RequestVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type GetResponse_Body_Init struct {
	ObjectId  *grpc.ObjectID  `json:"objectId"`
	Signature *grpc.Signature `json:"signature"`
	Header    *Header         `json:"header"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetResponse_Body_Init)(nil)
	_ encoding.ProtoUnmarshaler = (*GetResponse_Body_Init)(nil)
	_ json.Marshaler            = (*GetResponse_Body_Init)(nil)
	_ json.Unmarshaler          = (*GetResponse_Body_Init)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetResponse_Body_Init) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.ObjectId)
	size += proto.NestedStructureSize(2, x.Signature)
	size += proto.NestedStructureSize(3, x.Header)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetResponse_Body_Init) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetResponse_Body_Init) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.ObjectId != nil {
		x.ObjectId.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.Signature != nil {
		x.Signature.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.Header != nil {
		x.Header.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetResponse_Body_Init) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetResponse_Body_Init")
		}
		switch fc.FieldNum {
		case 1: // ObjectId
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "ObjectId")
			}
			x.ObjectId = new(grpc.ObjectID)
			if err := x.ObjectId.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // Signature
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Signature")
			}
			x.Signature = new(grpc.Signature)
			if err := x.Signature.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // Header
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Header")
			}
			x.Header = new(Header)
			if err := x.Header.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *GetResponse_Body_Init) GetObjectId() *grpc.ObjectID {
	if x != nil {
		return x.ObjectId
	}
	return nil
}
func (x *GetResponse_Body_Init) SetObjectId(v *grpc.ObjectID) {
	x.ObjectId = v
}
func (x *GetResponse_Body_Init) GetSignature() *grpc.Signature {
	if x != nil {
		return x.Signature
	}
	return nil
}
func (x *GetResponse_Body_Init) SetSignature(v *grpc.Signature) {
	x.Signature = v
}
func (x *GetResponse_Body_Init) GetHeader() *Header {
	if x != nil {
		return x.Header
	}
	return nil
}
func (x *GetResponse_Body_Init) SetHeader(v *Header) {
	x.Header = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetResponse_Body_Init) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetResponse_Body_Init) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.ObjectId != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"objectId\":"
			out.RawString(prefix)
			x.ObjectId.MarshalEasyJSON(out)
		}
	}
	{
		if x.Signature != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"signature\":"
			out.RawString(prefix)
			x.Signature.MarshalEasyJSON(out)
		}
	}
	{
		if x.Header != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"header\":"
			out.RawString(prefix)
			x.Header.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetResponse_Body_Init) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetResponse_Body_Init) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "objectId":
			{
				var f *grpc.ObjectID
				f = new(grpc.ObjectID)
				f.UnmarshalEasyJSON(in)
				x.ObjectId = f
			}
		case "signature":
			{
				var f *grpc.Signature
				f = new(grpc.Signature)
				f.UnmarshalEasyJSON(in)
				x.Signature = f
			}
		case "header":
			{
				var f *Header
				f = new(Header)
				f.UnmarshalEasyJSON(in)
				x.Header = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type GetResponse_Body struct {
	ObjectPart isGetResponse_Body_ObjectPart
}

var (
	_ encoding.ProtoMarshaler   = (*GetResponse_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*GetResponse_Body)(nil)
	_ json.Marshaler            = (*GetResponse_Body)(nil)
	_ json.Unmarshaler          = (*GetResponse_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetResponse_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	if inner, ok := x.ObjectPart.(*GetResponse_Body_Init_); ok {
		size += proto.NestedStructureSize(1, inner.Init)
	}
	if inner, ok := x.ObjectPart.(*GetResponse_Body_Chunk); ok {
		size += proto.BytesSize(2, inner.Chunk)
	}
	if inner, ok := x.ObjectPart.(*GetResponse_Body_SplitInfo); ok {
		size += proto.NestedStructureSize(3, inner.SplitInfo)
	}
	if inner, ok := x.ObjectPart.(*GetResponse_Body_EcInfo); ok {
		size += proto.NestedStructureSize(4, inner.EcInfo)
	}
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetResponse_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if inner, ok := x.ObjectPart.(*GetResponse_Body_Init_); ok {
		if inner.Init != nil {
			inner.Init.EmitProtobuf(mm.AppendMessage(1))
		}
	}
	if inner, ok := x.ObjectPart.(*GetResponse_Body_Chunk); ok {
		if len(inner.Chunk) != 0 {
			mm.AppendBytes(2, inner.Chunk)
		}
	}
	if inner, ok := x.ObjectPart.(*GetResponse_Body_SplitInfo); ok {
		if inner.SplitInfo != nil {
			inner.SplitInfo.EmitProtobuf(mm.AppendMessage(3))
		}
	}
	if inner, ok := x.ObjectPart.(*GetResponse_Body_EcInfo); ok {
		if inner.EcInfo != nil {
			inner.EcInfo.EmitProtobuf(mm.AppendMessage(4))
		}
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetResponse_Body")
		}
		switch fc.FieldNum {
		case 1: // Init
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Init")
			}
			oneofField := &GetResponse_Body_Init_{Init: new(GetResponse_Body_Init)}
			if err := oneofField.Init.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
			x.ObjectPart = oneofField
		case 2: // Chunk
			data, ok := fc.Bytes()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Chunk")
			}
			x.ObjectPart = &GetResponse_Body_Chunk{Chunk: data}
		case 3: // SplitInfo
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "SplitInfo")
			}
			oneofField := &GetResponse_Body_SplitInfo{SplitInfo: new(SplitInfo)}
			if err := oneofField.SplitInfo.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
			x.ObjectPart = oneofField
		case 4: // EcInfo
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "EcInfo")
			}
			oneofField := &GetResponse_Body_EcInfo{EcInfo: new(ECInfo)}
			if err := oneofField.EcInfo.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
			x.ObjectPart = oneofField
		}
	}
	return nil
}
func (x *GetResponse_Body) GetObjectPart() isGetResponse_Body_ObjectPart {
	if x != nil {
		return x.ObjectPart
	}
	return nil
}
func (x *GetResponse_Body) SetObjectPart(v isGetResponse_Body_ObjectPart) {
	x.ObjectPart = v
}
func (x *GetResponse_Body) GetInit() *GetResponse_Body_Init {
	if xx, ok := x.GetObjectPart().(*GetResponse_Body_Init_); ok {
		return xx.Init
	}
	return nil
}
func (x *GetResponse_Body) SetInit(v *GetResponse_Body_Init) {
	x.ObjectPart = &GetResponse_Body_Init_{Init: v}
}
func (x *GetResponse_Body) GetChunk() []byte {
	if xx, ok := x.GetObjectPart().(*GetResponse_Body_Chunk); ok {
		return xx.Chunk
	}
	return nil
}
func (x *GetResponse_Body) SetChunk(v *GetResponse_Body_Chunk) {
	x.ObjectPart = v
}
func (x *GetResponse_Body_Chunk) GetChunk() []byte {
	if x != nil {
		return x.Chunk
	}
	return nil
}
func (x *GetResponse_Body_Chunk) SetChunk(v []byte) {
	x.Chunk = v
}
func (x *GetResponse_Body) GetSplitInfo() *SplitInfo {
	if xx, ok := x.GetObjectPart().(*GetResponse_Body_SplitInfo); ok {
		return xx.SplitInfo
	}
	return nil
}
func (x *GetResponse_Body) SetSplitInfo(v *SplitInfo) {
	x.ObjectPart = &GetResponse_Body_SplitInfo{SplitInfo: v}
}
func (x *GetResponse_Body) GetEcInfo() *ECInfo {
	if xx, ok := x.GetObjectPart().(*GetResponse_Body_EcInfo); ok {
		return xx.EcInfo
	}
	return nil
}
func (x *GetResponse_Body) SetEcInfo(v *ECInfo) {
	x.ObjectPart = &GetResponse_Body_EcInfo{EcInfo: v}
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetResponse_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetResponse_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	switch xx := x.ObjectPart.(type) {
	case *GetResponse_Body_Init_:
		{
			if xx.Init != nil {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"init\":"
				out.RawString(prefix)
				xx.Init.MarshalEasyJSON(out)
			}
		}
	case *GetResponse_Body_Chunk:
		{
			if len(xx.Chunk) != 0 {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"chunk\":"
				out.RawString(prefix)
				out.Base64Bytes(xx.Chunk)
			}
		}
	case *GetResponse_Body_SplitInfo:
		{
			if xx.SplitInfo != nil {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"splitInfo\":"
				out.RawString(prefix)
				xx.SplitInfo.MarshalEasyJSON(out)
			}
		}
	case *GetResponse_Body_EcInfo:
		{
			if xx.EcInfo != nil {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"ecInfo\":"
				out.RawString(prefix)
				xx.EcInfo.MarshalEasyJSON(out)
			}
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetResponse_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "init":
			xx := new(GetResponse_Body_Init_)
			x.ObjectPart = xx
			{
				var f *GetResponse_Body_Init
				f = new(GetResponse_Body_Init)
				f.UnmarshalEasyJSON(in)
				xx.Init = f
			}
		case "chunk":
			xx := new(GetResponse_Body_Chunk)
			x.ObjectPart = xx
			{
				var f []byte
				f = in.Bytes()
				xx.Chunk = f
			}
		case "splitInfo":
			xx := new(GetResponse_Body_SplitInfo)
			x.ObjectPart = xx
			{
				var f *SplitInfo
				f = new(SplitInfo)
				f.UnmarshalEasyJSON(in)
				xx.SplitInfo = f
			}
		case "ecInfo":
			xx := new(GetResponse_Body_EcInfo)
			x.ObjectPart = xx
			{
				var f *ECInfo
				f = new(ECInfo)
				f.UnmarshalEasyJSON(in)
				xx.EcInfo = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type isGetResponse_Body_ObjectPart interface {
	isGetResponse_Body_ObjectPart()
}

type GetResponse_Body_Init_ struct {
	Init *GetResponse_Body_Init
}

type GetResponse_Body_Chunk struct {
	Chunk []byte
}

type GetResponse_Body_SplitInfo struct {
	SplitInfo *SplitInfo
}

type GetResponse_Body_EcInfo struct {
	EcInfo *ECInfo
}

func (*GetResponse_Body_Init_) isGetResponse_Body_ObjectPart() {}

func (*GetResponse_Body_Chunk) isGetResponse_Body_ObjectPart() {}

func (*GetResponse_Body_SplitInfo) isGetResponse_Body_ObjectPart() {}

func (*GetResponse_Body_EcInfo) isGetResponse_Body_ObjectPart() {}

type GetResponse struct {
	Body         *GetResponse_Body                 `json:"body"`
	MetaHeader   *grpc1.ResponseMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.ResponseVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetResponse)(nil)
	_ encoding.ProtoUnmarshaler = (*GetResponse)(nil)
	_ json.Marshaler            = (*GetResponse)(nil)
	_ json.Unmarshaler          = (*GetResponse)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetResponse) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *GetResponse) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *GetResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetResponse) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetResponse) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetResponse) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetResponse")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(GetResponse_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.ResponseMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.ResponseVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *GetResponse) GetBody() *GetResponse_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *GetResponse) SetBody(v *GetResponse_Body) {
	x.Body = v
}
func (x *GetResponse) GetMetaHeader() *grpc1.ResponseMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *GetResponse) SetMetaHeader(v *grpc1.ResponseMetaHeader) {
	x.MetaHeader = v
}
func (x *GetResponse) GetVerifyHeader() *grpc1.ResponseVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *GetResponse) SetVerifyHeader(v *grpc1.ResponseVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetResponse) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *GetResponse_Body
				f = new(GetResponse_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.ResponseMetaHeader
				f = new(grpc1.ResponseMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.ResponseVerificationHeader
				f = new(grpc1.ResponseVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PutRequest_Body_Init struct {
	ObjectId     *grpc.ObjectID  `json:"objectId"`
	Signature    *grpc.Signature `json:"signature"`
	Header       *Header         `json:"header"`
	CopiesNumber []uint32        `json:"copiesNumber"`
}

var (
	_ encoding.ProtoMarshaler   = (*PutRequest_Body_Init)(nil)
	_ encoding.ProtoUnmarshaler = (*PutRequest_Body_Init)(nil)
	_ json.Marshaler            = (*PutRequest_Body_Init)(nil)
	_ json.Unmarshaler          = (*PutRequest_Body_Init)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PutRequest_Body_Init) StableSize() (size int) {
	if x == nil {
		return 0
	}
	var n int
	size += proto.NestedStructureSize(1, x.ObjectId)
	size += proto.NestedStructureSize(2, x.Signature)
	size += proto.NestedStructureSize(3, x.Header)
	n, _ = proto.RepeatedUInt32Size(4, x.CopiesNumber)
	size += n
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PutRequest_Body_Init) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PutRequest_Body_Init) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.ObjectId != nil {
		x.ObjectId.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.Signature != nil {
		x.Signature.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.Header != nil {
		x.Header.EmitProtobuf(mm.AppendMessage(3))
	}
	if len(x.CopiesNumber) != 0 {
		mm.AppendUint32s(4, x.CopiesNumber)
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PutRequest_Body_Init) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PutRequest_Body_Init")
		}
		switch fc.FieldNum {
		case 1: // ObjectId
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "ObjectId")
			}
			x.ObjectId = new(grpc.ObjectID)
			if err := x.ObjectId.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // Signature
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Signature")
			}
			x.Signature = new(grpc.Signature)
			if err := x.Signature.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // Header
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Header")
			}
			x.Header = new(Header)
			if err := x.Header.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 4: // CopiesNumber
			data, ok := fc.UnpackUint32s(nil)
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "CopiesNumber")
			}
			x.CopiesNumber = data
		}
	}
	return nil
}
func (x *PutRequest_Body_Init) GetObjectId() *grpc.ObjectID {
	if x != nil {
		return x.ObjectId
	}
	return nil
}
func (x *PutRequest_Body_Init) SetObjectId(v *grpc.ObjectID) {
	x.ObjectId = v
}
func (x *PutRequest_Body_Init) GetSignature() *grpc.Signature {
	if x != nil {
		return x.Signature
	}
	return nil
}
func (x *PutRequest_Body_Init) SetSignature(v *grpc.Signature) {
	x.Signature = v
}
func (x *PutRequest_Body_Init) GetHeader() *Header {
	if x != nil {
		return x.Header
	}
	return nil
}
func (x *PutRequest_Body_Init) SetHeader(v *Header) {
	x.Header = v
}
func (x *PutRequest_Body_Init) GetCopiesNumber() []uint32 {
	if x != nil {
		return x.CopiesNumber
	}
	return nil
}
func (x *PutRequest_Body_Init) SetCopiesNumber(v []uint32) {
	x.CopiesNumber = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PutRequest_Body_Init) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PutRequest_Body_Init) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.ObjectId != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"objectId\":"
			out.RawString(prefix)
			x.ObjectId.MarshalEasyJSON(out)
		}
	}
	{
		if x.Signature != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"signature\":"
			out.RawString(prefix)
			x.Signature.MarshalEasyJSON(out)
		}
	}
	{
		if x.Header != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"header\":"
			out.RawString(prefix)
			x.Header.MarshalEasyJSON(out)
		}
	}
	{
		if len(x.CopiesNumber) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"copiesNumber\":"
			out.RawString(prefix)
			out.RawByte('[')
			for i := range x.CopiesNumber {
				if i != 0 {
					out.RawByte(',')
				}
				out.Uint32(x.CopiesNumber[i])
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PutRequest_Body_Init) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PutRequest_Body_Init) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "objectId":
			{
				var f *grpc.ObjectID
				f = new(grpc.ObjectID)
				f.UnmarshalEasyJSON(in)
				x.ObjectId = f
			}
		case "signature":
			{
				var f *grpc.Signature
				f = new(grpc.Signature)
				f.UnmarshalEasyJSON(in)
				x.Signature = f
			}
		case "header":
			{
				var f *Header
				f = new(Header)
				f.UnmarshalEasyJSON(in)
				x.Header = f
			}
		case "copiesNumber":
			{
				var f uint32
				var list []uint32
				in.Delim('[')
				for !in.IsDelim(']') {
					f = in.Uint32()
					list = append(list, f)
					in.WantComma()
				}
				x.CopiesNumber = list
				in.Delim(']')
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PutRequest_Body struct {
	ObjectPart isPutRequest_Body_ObjectPart
}

var (
	_ encoding.ProtoMarshaler   = (*PutRequest_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*PutRequest_Body)(nil)
	_ json.Marshaler            = (*PutRequest_Body)(nil)
	_ json.Unmarshaler          = (*PutRequest_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PutRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	if inner, ok := x.ObjectPart.(*PutRequest_Body_Init_); ok {
		size += proto.NestedStructureSize(1, inner.Init)
	}
	if inner, ok := x.ObjectPart.(*PutRequest_Body_Chunk); ok {
		size += proto.BytesSize(2, inner.Chunk)
	}
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PutRequest_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PutRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if inner, ok := x.ObjectPart.(*PutRequest_Body_Init_); ok {
		if inner.Init != nil {
			inner.Init.EmitProtobuf(mm.AppendMessage(1))
		}
	}
	if inner, ok := x.ObjectPart.(*PutRequest_Body_Chunk); ok {
		if len(inner.Chunk) != 0 {
			mm.AppendBytes(2, inner.Chunk)
		}
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PutRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PutRequest_Body")
		}
		switch fc.FieldNum {
		case 1: // Init
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Init")
			}
			oneofField := &PutRequest_Body_Init_{Init: new(PutRequest_Body_Init)}
			if err := oneofField.Init.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
			x.ObjectPart = oneofField
		case 2: // Chunk
			data, ok := fc.Bytes()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Chunk")
			}
			x.ObjectPart = &PutRequest_Body_Chunk{Chunk: data}
		}
	}
	return nil
}
func (x *PutRequest_Body) GetObjectPart() isPutRequest_Body_ObjectPart {
	if x != nil {
		return x.ObjectPart
	}
	return nil
}
func (x *PutRequest_Body) SetObjectPart(v isPutRequest_Body_ObjectPart) {
	x.ObjectPart = v
}
func (x *PutRequest_Body) GetInit() *PutRequest_Body_Init {
	if xx, ok := x.GetObjectPart().(*PutRequest_Body_Init_); ok {
		return xx.Init
	}
	return nil
}
func (x *PutRequest_Body) SetInit(v *PutRequest_Body_Init) {
	x.ObjectPart = &PutRequest_Body_Init_{Init: v}
}
func (x *PutRequest_Body) GetChunk() []byte {
	if xx, ok := x.GetObjectPart().(*PutRequest_Body_Chunk); ok {
		return xx.Chunk
	}
	return nil
}
func (x *PutRequest_Body) SetChunk(v *PutRequest_Body_Chunk) {
	x.ObjectPart = v
}
func (x *PutRequest_Body_Chunk) GetChunk() []byte {
	if x != nil {
		return x.Chunk
	}
	return nil
}
func (x *PutRequest_Body_Chunk) SetChunk(v []byte) {
	x.Chunk = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PutRequest_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PutRequest_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	switch xx := x.ObjectPart.(type) {
	case *PutRequest_Body_Init_:
		{
			if xx.Init != nil {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"init\":"
				out.RawString(prefix)
				xx.Init.MarshalEasyJSON(out)
			}
		}
	case *PutRequest_Body_Chunk:
		{
			if len(xx.Chunk) != 0 {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"chunk\":"
				out.RawString(prefix)
				out.Base64Bytes(xx.Chunk)
			}
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PutRequest_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PutRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "init":
			xx := new(PutRequest_Body_Init_)
			x.ObjectPart = xx
			{
				var f *PutRequest_Body_Init
				f = new(PutRequest_Body_Init)
				f.UnmarshalEasyJSON(in)
				xx.Init = f
			}
		case "chunk":
			xx := new(PutRequest_Body_Chunk)
			x.ObjectPart = xx
			{
				var f []byte
				f = in.Bytes()
				xx.Chunk = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type isPutRequest_Body_ObjectPart interface {
	isPutRequest_Body_ObjectPart()
}

type PutRequest_Body_Init_ struct {
	Init *PutRequest_Body_Init
}

type PutRequest_Body_Chunk struct {
	Chunk []byte
}

func (*PutRequest_Body_Init_) isPutRequest_Body_ObjectPart() {}

func (*PutRequest_Body_Chunk) isPutRequest_Body_ObjectPart() {}

type PutRequest struct {
	Body         *PutRequest_Body                 `json:"body"`
	MetaHeader   *grpc1.RequestMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.RequestVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*PutRequest)(nil)
	_ encoding.ProtoUnmarshaler = (*PutRequest)(nil)
	_ json.Marshaler            = (*PutRequest)(nil)
	_ json.Unmarshaler          = (*PutRequest)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PutRequest) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *PutRequest) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *PutRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PutRequest) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PutRequest) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PutRequest) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PutRequest")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(PutRequest_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.RequestMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.RequestVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *PutRequest) GetBody() *PutRequest_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *PutRequest) SetBody(v *PutRequest_Body) {
	x.Body = v
}
func (x *PutRequest) GetMetaHeader() *grpc1.RequestMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *PutRequest) SetMetaHeader(v *grpc1.RequestMetaHeader) {
	x.MetaHeader = v
}
func (x *PutRequest) GetVerifyHeader() *grpc1.RequestVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *PutRequest) SetVerifyHeader(v *grpc1.RequestVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PutRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PutRequest) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PutRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PutRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *PutRequest_Body
				f = new(PutRequest_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.RequestMetaHeader
				f = new(grpc1.RequestMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.RequestVerificationHeader
				f = new(grpc1.RequestVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PutResponse_Body struct {
	ObjectId *grpc.ObjectID `json:"objectId"`
}

var (
	_ encoding.ProtoMarshaler   = (*PutResponse_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*PutResponse_Body)(nil)
	_ json.Marshaler            = (*PutResponse_Body)(nil)
	_ json.Unmarshaler          = (*PutResponse_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PutResponse_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.ObjectId)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PutResponse_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PutResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.ObjectId != nil {
		x.ObjectId.EmitProtobuf(mm.AppendMessage(1))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PutResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PutResponse_Body")
		}
		switch fc.FieldNum {
		case 1: // ObjectId
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "ObjectId")
			}
			x.ObjectId = new(grpc.ObjectID)
			if err := x.ObjectId.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *PutResponse_Body) GetObjectId() *grpc.ObjectID {
	if x != nil {
		return x.ObjectId
	}
	return nil
}
func (x *PutResponse_Body) SetObjectId(v *grpc.ObjectID) {
	x.ObjectId = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PutResponse_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PutResponse_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.ObjectId != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"objectId\":"
			out.RawString(prefix)
			x.ObjectId.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PutResponse_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PutResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "objectId":
			{
				var f *grpc.ObjectID
				f = new(grpc.ObjectID)
				f.UnmarshalEasyJSON(in)
				x.ObjectId = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PutResponse struct {
	Body         *PutResponse_Body                 `json:"body"`
	MetaHeader   *grpc1.ResponseMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.ResponseVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*PutResponse)(nil)
	_ encoding.ProtoUnmarshaler = (*PutResponse)(nil)
	_ json.Marshaler            = (*PutResponse)(nil)
	_ json.Unmarshaler          = (*PutResponse)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PutResponse) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *PutResponse) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *PutResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PutResponse) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PutResponse) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PutResponse) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PutResponse")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(PutResponse_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.ResponseMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.ResponseVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *PutResponse) GetBody() *PutResponse_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *PutResponse) SetBody(v *PutResponse_Body) {
	x.Body = v
}
func (x *PutResponse) GetMetaHeader() *grpc1.ResponseMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *PutResponse) SetMetaHeader(v *grpc1.ResponseMetaHeader) {
	x.MetaHeader = v
}
func (x *PutResponse) GetVerifyHeader() *grpc1.ResponseVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *PutResponse) SetVerifyHeader(v *grpc1.ResponseVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PutResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PutResponse) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PutResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PutResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *PutResponse_Body
				f = new(PutResponse_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.ResponseMetaHeader
				f = new(grpc1.ResponseMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.ResponseVerificationHeader
				f = new(grpc1.ResponseVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type DeleteRequest_Body struct {
	Address *grpc.Address `json:"address"`
}

var (
	_ encoding.ProtoMarshaler   = (*DeleteRequest_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*DeleteRequest_Body)(nil)
	_ json.Marshaler            = (*DeleteRequest_Body)(nil)
	_ json.Unmarshaler          = (*DeleteRequest_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *DeleteRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Address)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *DeleteRequest_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *DeleteRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Address != nil {
		x.Address.EmitProtobuf(mm.AppendMessage(1))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *DeleteRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "DeleteRequest_Body")
		}
		switch fc.FieldNum {
		case 1: // Address
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Address")
			}
			x.Address = new(grpc.Address)
			if err := x.Address.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *DeleteRequest_Body) GetAddress() *grpc.Address {
	if x != nil {
		return x.Address
	}
	return nil
}
func (x *DeleteRequest_Body) SetAddress(v *grpc.Address) {
	x.Address = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *DeleteRequest_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *DeleteRequest_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Address != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"address\":"
			out.RawString(prefix)
			x.Address.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *DeleteRequest_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *DeleteRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "address":
			{
				var f *grpc.Address
				f = new(grpc.Address)
				f.UnmarshalEasyJSON(in)
				x.Address = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type DeleteRequest struct {
	Body         *DeleteRequest_Body              `json:"body"`
	MetaHeader   *grpc1.RequestMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.RequestVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*DeleteRequest)(nil)
	_ encoding.ProtoUnmarshaler = (*DeleteRequest)(nil)
	_ json.Marshaler            = (*DeleteRequest)(nil)
	_ json.Unmarshaler          = (*DeleteRequest)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *DeleteRequest) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *DeleteRequest) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *DeleteRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *DeleteRequest) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *DeleteRequest) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *DeleteRequest) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "DeleteRequest")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(DeleteRequest_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.RequestMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.RequestVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *DeleteRequest) GetBody() *DeleteRequest_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *DeleteRequest) SetBody(v *DeleteRequest_Body) {
	x.Body = v
}
func (x *DeleteRequest) GetMetaHeader() *grpc1.RequestMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *DeleteRequest) SetMetaHeader(v *grpc1.RequestMetaHeader) {
	x.MetaHeader = v
}
func (x *DeleteRequest) GetVerifyHeader() *grpc1.RequestVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *DeleteRequest) SetVerifyHeader(v *grpc1.RequestVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *DeleteRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *DeleteRequest) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *DeleteRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *DeleteRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *DeleteRequest_Body
				f = new(DeleteRequest_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.RequestMetaHeader
				f = new(grpc1.RequestMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.RequestVerificationHeader
				f = new(grpc1.RequestVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type DeleteResponse_Body struct {
	Tombstone *grpc.Address `json:"tombstone"`
}

var (
	_ encoding.ProtoMarshaler   = (*DeleteResponse_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*DeleteResponse_Body)(nil)
	_ json.Marshaler            = (*DeleteResponse_Body)(nil)
	_ json.Unmarshaler          = (*DeleteResponse_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *DeleteResponse_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Tombstone)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *DeleteResponse_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *DeleteResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Tombstone != nil {
		x.Tombstone.EmitProtobuf(mm.AppendMessage(1))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *DeleteResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "DeleteResponse_Body")
		}
		switch fc.FieldNum {
		case 1: // Tombstone
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Tombstone")
			}
			x.Tombstone = new(grpc.Address)
			if err := x.Tombstone.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *DeleteResponse_Body) GetTombstone() *grpc.Address {
	if x != nil {
		return x.Tombstone
	}
	return nil
}
func (x *DeleteResponse_Body) SetTombstone(v *grpc.Address) {
	x.Tombstone = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *DeleteResponse_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *DeleteResponse_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Tombstone != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"tombstone\":"
			out.RawString(prefix)
			x.Tombstone.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *DeleteResponse_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *DeleteResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "tombstone":
			{
				var f *grpc.Address
				f = new(grpc.Address)
				f.UnmarshalEasyJSON(in)
				x.Tombstone = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type DeleteResponse struct {
	Body         *DeleteResponse_Body              `json:"body"`
	MetaHeader   *grpc1.ResponseMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.ResponseVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*DeleteResponse)(nil)
	_ encoding.ProtoUnmarshaler = (*DeleteResponse)(nil)
	_ json.Marshaler            = (*DeleteResponse)(nil)
	_ json.Unmarshaler          = (*DeleteResponse)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *DeleteResponse) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *DeleteResponse) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *DeleteResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *DeleteResponse) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *DeleteResponse) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *DeleteResponse) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "DeleteResponse")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(DeleteResponse_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.ResponseMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.ResponseVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *DeleteResponse) GetBody() *DeleteResponse_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *DeleteResponse) SetBody(v *DeleteResponse_Body) {
	x.Body = v
}
func (x *DeleteResponse) GetMetaHeader() *grpc1.ResponseMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *DeleteResponse) SetMetaHeader(v *grpc1.ResponseMetaHeader) {
	x.MetaHeader = v
}
func (x *DeleteResponse) GetVerifyHeader() *grpc1.ResponseVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *DeleteResponse) SetVerifyHeader(v *grpc1.ResponseVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *DeleteResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *DeleteResponse) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *DeleteResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *DeleteResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *DeleteResponse_Body
				f = new(DeleteResponse_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.ResponseMetaHeader
				f = new(grpc1.ResponseMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.ResponseVerificationHeader
				f = new(grpc1.ResponseVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type HeadRequest_Body struct {
	Address  *grpc.Address `json:"address"`
	MainOnly bool          `json:"mainOnly"`
	Raw      bool          `json:"raw"`
}

var (
	_ encoding.ProtoMarshaler   = (*HeadRequest_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*HeadRequest_Body)(nil)
	_ json.Marshaler            = (*HeadRequest_Body)(nil)
	_ json.Unmarshaler          = (*HeadRequest_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *HeadRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Address)
	size += proto.BoolSize(2, x.MainOnly)
	size += proto.BoolSize(3, x.Raw)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *HeadRequest_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *HeadRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Address != nil {
		x.Address.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MainOnly {
		mm.AppendBool(2, x.MainOnly)
	}
	if x.Raw {
		mm.AppendBool(3, x.Raw)
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *HeadRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "HeadRequest_Body")
		}
		switch fc.FieldNum {
		case 1: // Address
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Address")
			}
			x.Address = new(grpc.Address)
			if err := x.Address.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MainOnly
			data, ok := fc.Bool()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MainOnly")
			}
			x.MainOnly = data
		case 3: // Raw
			data, ok := fc.Bool()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Raw")
			}
			x.Raw = data
		}
	}
	return nil
}
func (x *HeadRequest_Body) GetAddress() *grpc.Address {
	if x != nil {
		return x.Address
	}
	return nil
}
func (x *HeadRequest_Body) SetAddress(v *grpc.Address) {
	x.Address = v
}
func (x *HeadRequest_Body) GetMainOnly() bool {
	if x != nil {
		return x.MainOnly
	}
	return false
}
func (x *HeadRequest_Body) SetMainOnly(v bool) {
	x.MainOnly = v
}
func (x *HeadRequest_Body) GetRaw() bool {
	if x != nil {
		return x.Raw
	}
	return false
}
func (x *HeadRequest_Body) SetRaw(v bool) {
	x.Raw = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *HeadRequest_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *HeadRequest_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Address != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"address\":"
			out.RawString(prefix)
			x.Address.MarshalEasyJSON(out)
		}
	}
	{
		if x.MainOnly {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"mainOnly\":"
			out.RawString(prefix)
			out.Bool(x.MainOnly)
		}
	}
	{
		if x.Raw {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"raw\":"
			out.RawString(prefix)
			out.Bool(x.Raw)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *HeadRequest_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *HeadRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "address":
			{
				var f *grpc.Address
				f = new(grpc.Address)
				f.UnmarshalEasyJSON(in)
				x.Address = f
			}
		case "mainOnly":
			{
				var f bool
				f = in.Bool()
				x.MainOnly = f
			}
		case "raw":
			{
				var f bool
				f = in.Bool()
				x.Raw = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type HeadRequest struct {
	Body         *HeadRequest_Body                `json:"body"`
	MetaHeader   *grpc1.RequestMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.RequestVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*HeadRequest)(nil)
	_ encoding.ProtoUnmarshaler = (*HeadRequest)(nil)
	_ json.Marshaler            = (*HeadRequest)(nil)
	_ json.Unmarshaler          = (*HeadRequest)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *HeadRequest) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *HeadRequest) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *HeadRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *HeadRequest) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *HeadRequest) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *HeadRequest) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "HeadRequest")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(HeadRequest_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.RequestMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.RequestVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *HeadRequest) GetBody() *HeadRequest_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *HeadRequest) SetBody(v *HeadRequest_Body) {
	x.Body = v
}
func (x *HeadRequest) GetMetaHeader() *grpc1.RequestMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *HeadRequest) SetMetaHeader(v *grpc1.RequestMetaHeader) {
	x.MetaHeader = v
}
func (x *HeadRequest) GetVerifyHeader() *grpc1.RequestVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *HeadRequest) SetVerifyHeader(v *grpc1.RequestVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *HeadRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *HeadRequest) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *HeadRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *HeadRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *HeadRequest_Body
				f = new(HeadRequest_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.RequestMetaHeader
				f = new(grpc1.RequestMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.RequestVerificationHeader
				f = new(grpc1.RequestVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type HeaderWithSignature struct {
	Header    *Header         `json:"header"`
	Signature *grpc.Signature `json:"signature"`
}

var (
	_ encoding.ProtoMarshaler   = (*HeaderWithSignature)(nil)
	_ encoding.ProtoUnmarshaler = (*HeaderWithSignature)(nil)
	_ json.Marshaler            = (*HeaderWithSignature)(nil)
	_ json.Unmarshaler          = (*HeaderWithSignature)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *HeaderWithSignature) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Header)
	size += proto.NestedStructureSize(2, x.Signature)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *HeaderWithSignature) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *HeaderWithSignature) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Header != nil {
		x.Header.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.Signature != nil {
		x.Signature.EmitProtobuf(mm.AppendMessage(2))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *HeaderWithSignature) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "HeaderWithSignature")
		}
		switch fc.FieldNum {
		case 1: // Header
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Header")
			}
			x.Header = new(Header)
			if err := x.Header.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // Signature
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Signature")
			}
			x.Signature = new(grpc.Signature)
			if err := x.Signature.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *HeaderWithSignature) GetHeader() *Header {
	if x != nil {
		return x.Header
	}
	return nil
}
func (x *HeaderWithSignature) SetHeader(v *Header) {
	x.Header = v
}
func (x *HeaderWithSignature) GetSignature() *grpc.Signature {
	if x != nil {
		return x.Signature
	}
	return nil
}
func (x *HeaderWithSignature) SetSignature(v *grpc.Signature) {
	x.Signature = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *HeaderWithSignature) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *HeaderWithSignature) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Header != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"header\":"
			out.RawString(prefix)
			x.Header.MarshalEasyJSON(out)
		}
	}
	{
		if x.Signature != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"signature\":"
			out.RawString(prefix)
			x.Signature.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *HeaderWithSignature) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *HeaderWithSignature) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "header":
			{
				var f *Header
				f = new(Header)
				f.UnmarshalEasyJSON(in)
				x.Header = f
			}
		case "signature":
			{
				var f *grpc.Signature
				f = new(grpc.Signature)
				f.UnmarshalEasyJSON(in)
				x.Signature = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type HeadResponse_Body struct {
	Head isHeadResponse_Body_Head
}

var (
	_ encoding.ProtoMarshaler   = (*HeadResponse_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*HeadResponse_Body)(nil)
	_ json.Marshaler            = (*HeadResponse_Body)(nil)
	_ json.Unmarshaler          = (*HeadResponse_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *HeadResponse_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	if inner, ok := x.Head.(*HeadResponse_Body_Header); ok {
		size += proto.NestedStructureSize(1, inner.Header)
	}
	if inner, ok := x.Head.(*HeadResponse_Body_ShortHeader); ok {
		size += proto.NestedStructureSize(2, inner.ShortHeader)
	}
	if inner, ok := x.Head.(*HeadResponse_Body_SplitInfo); ok {
		size += proto.NestedStructureSize(3, inner.SplitInfo)
	}
	if inner, ok := x.Head.(*HeadResponse_Body_EcInfo); ok {
		size += proto.NestedStructureSize(4, inner.EcInfo)
	}
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *HeadResponse_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *HeadResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if inner, ok := x.Head.(*HeadResponse_Body_Header); ok {
		if inner.Header != nil {
			inner.Header.EmitProtobuf(mm.AppendMessage(1))
		}
	}
	if inner, ok := x.Head.(*HeadResponse_Body_ShortHeader); ok {
		if inner.ShortHeader != nil {
			inner.ShortHeader.EmitProtobuf(mm.AppendMessage(2))
		}
	}
	if inner, ok := x.Head.(*HeadResponse_Body_SplitInfo); ok {
		if inner.SplitInfo != nil {
			inner.SplitInfo.EmitProtobuf(mm.AppendMessage(3))
		}
	}
	if inner, ok := x.Head.(*HeadResponse_Body_EcInfo); ok {
		if inner.EcInfo != nil {
			inner.EcInfo.EmitProtobuf(mm.AppendMessage(4))
		}
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *HeadResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "HeadResponse_Body")
		}
		switch fc.FieldNum {
		case 1: // Header
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Header")
			}
			oneofField := &HeadResponse_Body_Header{Header: new(HeaderWithSignature)}
			if err := oneofField.Header.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
			x.Head = oneofField
		case 2: // ShortHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "ShortHeader")
			}
			oneofField := &HeadResponse_Body_ShortHeader{ShortHeader: new(ShortHeader)}
			if err := oneofField.ShortHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
			x.Head = oneofField
		case 3: // SplitInfo
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "SplitInfo")
			}
			oneofField := &HeadResponse_Body_SplitInfo{SplitInfo: new(SplitInfo)}
			if err := oneofField.SplitInfo.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
			x.Head = oneofField
		case 4: // EcInfo
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "EcInfo")
			}
			oneofField := &HeadResponse_Body_EcInfo{EcInfo: new(ECInfo)}
			if err := oneofField.EcInfo.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
			x.Head = oneofField
		}
	}
	return nil
}
func (x *HeadResponse_Body) GetHead() isHeadResponse_Body_Head {
	if x != nil {
		return x.Head
	}
	return nil
}
func (x *HeadResponse_Body) SetHead(v isHeadResponse_Body_Head) {
	x.Head = v
}
func (x *HeadResponse_Body) GetHeader() *HeaderWithSignature {
	if xx, ok := x.GetHead().(*HeadResponse_Body_Header); ok {
		return xx.Header
	}
	return nil
}
func (x *HeadResponse_Body) SetHeader(v *HeaderWithSignature) {
	x.Head = &HeadResponse_Body_Header{Header: v}
}
func (x *HeadResponse_Body) GetShortHeader() *ShortHeader {
	if xx, ok := x.GetHead().(*HeadResponse_Body_ShortHeader); ok {
		return xx.ShortHeader
	}
	return nil
}
func (x *HeadResponse_Body) SetShortHeader(v *ShortHeader) {
	x.Head = &HeadResponse_Body_ShortHeader{ShortHeader: v}
}
func (x *HeadResponse_Body) GetSplitInfo() *SplitInfo {
	if xx, ok := x.GetHead().(*HeadResponse_Body_SplitInfo); ok {
		return xx.SplitInfo
	}
	return nil
}
func (x *HeadResponse_Body) SetSplitInfo(v *SplitInfo) {
	x.Head = &HeadResponse_Body_SplitInfo{SplitInfo: v}
}
func (x *HeadResponse_Body) GetEcInfo() *ECInfo {
	if xx, ok := x.GetHead().(*HeadResponse_Body_EcInfo); ok {
		return xx.EcInfo
	}
	return nil
}
func (x *HeadResponse_Body) SetEcInfo(v *ECInfo) {
	x.Head = &HeadResponse_Body_EcInfo{EcInfo: v}
}

// MarshalJSON implements the json.Marshaler interface.
func (x *HeadResponse_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *HeadResponse_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	switch xx := x.Head.(type) {
	case *HeadResponse_Body_Header:
		{
			if xx.Header != nil {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"header\":"
				out.RawString(prefix)
				xx.Header.MarshalEasyJSON(out)
			}
		}
	case *HeadResponse_Body_ShortHeader:
		{
			if xx.ShortHeader != nil {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"shortHeader\":"
				out.RawString(prefix)
				xx.ShortHeader.MarshalEasyJSON(out)
			}
		}
	case *HeadResponse_Body_SplitInfo:
		{
			if xx.SplitInfo != nil {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"splitInfo\":"
				out.RawString(prefix)
				xx.SplitInfo.MarshalEasyJSON(out)
			}
		}
	case *HeadResponse_Body_EcInfo:
		{
			if xx.EcInfo != nil {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"ecInfo\":"
				out.RawString(prefix)
				xx.EcInfo.MarshalEasyJSON(out)
			}
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *HeadResponse_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *HeadResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "header":
			xx := new(HeadResponse_Body_Header)
			x.Head = xx
			{
				var f *HeaderWithSignature
				f = new(HeaderWithSignature)
				f.UnmarshalEasyJSON(in)
				xx.Header = f
			}
		case "shortHeader":
			xx := new(HeadResponse_Body_ShortHeader)
			x.Head = xx
			{
				var f *ShortHeader
				f = new(ShortHeader)
				f.UnmarshalEasyJSON(in)
				xx.ShortHeader = f
			}
		case "splitInfo":
			xx := new(HeadResponse_Body_SplitInfo)
			x.Head = xx
			{
				var f *SplitInfo
				f = new(SplitInfo)
				f.UnmarshalEasyJSON(in)
				xx.SplitInfo = f
			}
		case "ecInfo":
			xx := new(HeadResponse_Body_EcInfo)
			x.Head = xx
			{
				var f *ECInfo
				f = new(ECInfo)
				f.UnmarshalEasyJSON(in)
				xx.EcInfo = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type isHeadResponse_Body_Head interface {
	isHeadResponse_Body_Head()
}

type HeadResponse_Body_Header struct {
	Header *HeaderWithSignature
}

type HeadResponse_Body_ShortHeader struct {
	ShortHeader *ShortHeader
}

type HeadResponse_Body_SplitInfo struct {
	SplitInfo *SplitInfo
}

type HeadResponse_Body_EcInfo struct {
	EcInfo *ECInfo
}

func (*HeadResponse_Body_Header) isHeadResponse_Body_Head() {}

func (*HeadResponse_Body_ShortHeader) isHeadResponse_Body_Head() {}

func (*HeadResponse_Body_SplitInfo) isHeadResponse_Body_Head() {}

func (*HeadResponse_Body_EcInfo) isHeadResponse_Body_Head() {}

type HeadResponse struct {
	Body         *HeadResponse_Body                `json:"body"`
	MetaHeader   *grpc1.ResponseMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.ResponseVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*HeadResponse)(nil)
	_ encoding.ProtoUnmarshaler = (*HeadResponse)(nil)
	_ json.Marshaler            = (*HeadResponse)(nil)
	_ json.Unmarshaler          = (*HeadResponse)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *HeadResponse) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *HeadResponse) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *HeadResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *HeadResponse) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *HeadResponse) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *HeadResponse) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "HeadResponse")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(HeadResponse_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.ResponseMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.ResponseVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *HeadResponse) GetBody() *HeadResponse_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *HeadResponse) SetBody(v *HeadResponse_Body) {
	x.Body = v
}
func (x *HeadResponse) GetMetaHeader() *grpc1.ResponseMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *HeadResponse) SetMetaHeader(v *grpc1.ResponseMetaHeader) {
	x.MetaHeader = v
}
func (x *HeadResponse) GetVerifyHeader() *grpc1.ResponseVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *HeadResponse) SetVerifyHeader(v *grpc1.ResponseVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *HeadResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *HeadResponse) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *HeadResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *HeadResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *HeadResponse_Body
				f = new(HeadResponse_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.ResponseMetaHeader
				f = new(grpc1.ResponseMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.ResponseVerificationHeader
				f = new(grpc1.ResponseVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type SearchRequest_Body_Filter struct {
	MatchType MatchType `json:"matchType"`
	Key       string    `json:"key"`
	Value     string    `json:"value"`
}

var (
	_ encoding.ProtoMarshaler   = (*SearchRequest_Body_Filter)(nil)
	_ encoding.ProtoUnmarshaler = (*SearchRequest_Body_Filter)(nil)
	_ json.Marshaler            = (*SearchRequest_Body_Filter)(nil)
	_ json.Unmarshaler          = (*SearchRequest_Body_Filter)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *SearchRequest_Body_Filter) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.EnumSize(1, int32(x.MatchType))
	size += proto.StringSize(2, x.Key)
	size += proto.StringSize(3, x.Value)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *SearchRequest_Body_Filter) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *SearchRequest_Body_Filter) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if int32(x.MatchType) != 0 {
		mm.AppendInt32(1, int32(x.MatchType))
	}
	if len(x.Key) != 0 {
		mm.AppendString(2, x.Key)
	}
	if len(x.Value) != 0 {
		mm.AppendString(3, x.Value)
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *SearchRequest_Body_Filter) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "SearchRequest_Body_Filter")
		}
		switch fc.FieldNum {
		case 1: // MatchType
			data, ok := fc.Int32()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MatchType")
			}
			x.MatchType = MatchType(data)
		case 2: // Key
			data, ok := fc.String()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Key")
			}
			x.Key = data
		case 3: // Value
			data, ok := fc.String()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Value")
			}
			x.Value = data
		}
	}
	return nil
}
func (x *SearchRequest_Body_Filter) GetMatchType() MatchType {
	if x != nil {
		return x.MatchType
	}
	return 0
}
func (x *SearchRequest_Body_Filter) SetMatchType(v MatchType) {
	x.MatchType = v
}
func (x *SearchRequest_Body_Filter) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}
func (x *SearchRequest_Body_Filter) SetKey(v string) {
	x.Key = v
}
func (x *SearchRequest_Body_Filter) GetValue() string {
	if x != nil {
		return x.Value
	}
	return ""
}
func (x *SearchRequest_Body_Filter) SetValue(v string) {
	x.Value = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *SearchRequest_Body_Filter) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *SearchRequest_Body_Filter) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.MatchType != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"matchType\":"
			out.RawString(prefix)
			v := int32(x.MatchType)
			if vv, ok := MatchType_name[v]; ok {
				out.String(vv)
			} else {
				out.Int32(v)
			}
		}
	}
	{
		if len(x.Key) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"key\":"
			out.RawString(prefix)
			out.String(x.Key)
		}
	}
	{
		if len(x.Value) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"value\":"
			out.RawString(prefix)
			out.String(x.Value)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *SearchRequest_Body_Filter) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *SearchRequest_Body_Filter) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "matchType":
			{
				var f MatchType
				var parsedValue MatchType
				switch v := in.Interface().(type) {
				case string:
					if vv, ok := MatchType_value[v]; ok {
						parsedValue = MatchType(vv)
						break
					}
					vv, err := strconv.ParseInt(v, 10, 32)
					if err != nil {
						in.AddError(err)
						return
					}
					parsedValue = MatchType(vv)
				case float64:
					parsedValue = MatchType(v)
				}
				f = parsedValue
				x.MatchType = f
			}
		case "key":
			{
				var f string
				f = in.String()
				x.Key = f
			}
		case "value":
			{
				var f string
				f = in.String()
				x.Value = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type SearchRequest_Body struct {
	ContainerId *grpc.ContainerID           `json:"containerId"`
	Version     uint32                      `json:"version"`
	Filters     []SearchRequest_Body_Filter `json:"filters"`
}

var (
	_ encoding.ProtoMarshaler   = (*SearchRequest_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*SearchRequest_Body)(nil)
	_ json.Marshaler            = (*SearchRequest_Body)(nil)
	_ json.Unmarshaler          = (*SearchRequest_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *SearchRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.ContainerId)
	size += proto.UInt32Size(2, x.Version)
	for i := range x.Filters {
		size += proto.NestedStructureSizeUnchecked(3, &x.Filters[i])
	}
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *SearchRequest_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *SearchRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.ContainerId != nil {
		x.ContainerId.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.Version != 0 {
		mm.AppendUint32(2, x.Version)
	}
	for i := range x.Filters {
		x.Filters[i].EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *SearchRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "SearchRequest_Body")
		}
		switch fc.FieldNum {
		case 1: // ContainerId
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "ContainerId")
			}
			x.ContainerId = new(grpc.ContainerID)
			if err := x.ContainerId.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // Version
			data, ok := fc.Uint32()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Version")
			}
			x.Version = data
		case 3: // Filters
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Filters")
			}
			x.Filters = append(x.Filters, SearchRequest_Body_Filter{})
			ff := &x.Filters[len(x.Filters)-1]
			if err := ff.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *SearchRequest_Body) GetContainerId() *grpc.ContainerID {
	if x != nil {
		return x.ContainerId
	}
	return nil
}
func (x *SearchRequest_Body) SetContainerId(v *grpc.ContainerID) {
	x.ContainerId = v
}
func (x *SearchRequest_Body) GetVersion() uint32 {
	if x != nil {
		return x.Version
	}
	return 0
}
func (x *SearchRequest_Body) SetVersion(v uint32) {
	x.Version = v
}
func (x *SearchRequest_Body) GetFilters() []SearchRequest_Body_Filter {
	if x != nil {
		return x.Filters
	}
	return nil
}
func (x *SearchRequest_Body) SetFilters(v []SearchRequest_Body_Filter) {
	x.Filters = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *SearchRequest_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *SearchRequest_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.ContainerId != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"containerId\":"
			out.RawString(prefix)
			x.ContainerId.MarshalEasyJSON(out)
		}
	}
	{
		if x.Version != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"version\":"
			out.RawString(prefix)
			out.Uint32(x.Version)
		}
	}
	{
		if len(x.Filters) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"filters\":"
			out.RawString(prefix)
			out.RawByte('[')
			for i := range x.Filters {
				if i != 0 {
					out.RawByte(',')
				}
				x.Filters[i].MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *SearchRequest_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *SearchRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "containerId":
			{
				var f *grpc.ContainerID
				f = new(grpc.ContainerID)
				f.UnmarshalEasyJSON(in)
				x.ContainerId = f
			}
		case "version":
			{
				var f uint32
				f = in.Uint32()
				x.Version = f
			}
		case "filters":
			{
				var f SearchRequest_Body_Filter
				var list []SearchRequest_Body_Filter
				in.Delim('[')
				for !in.IsDelim(']') {
					f = SearchRequest_Body_Filter{}
					f.UnmarshalEasyJSON(in)
					list = append(list, f)
					in.WantComma()
				}
				x.Filters = list
				in.Delim(']')
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type SearchRequest struct {
	Body         *SearchRequest_Body              `json:"body"`
	MetaHeader   *grpc1.RequestMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.RequestVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*SearchRequest)(nil)
	_ encoding.ProtoUnmarshaler = (*SearchRequest)(nil)
	_ json.Marshaler            = (*SearchRequest)(nil)
	_ json.Unmarshaler          = (*SearchRequest)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *SearchRequest) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *SearchRequest) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *SearchRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *SearchRequest) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *SearchRequest) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *SearchRequest) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "SearchRequest")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(SearchRequest_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.RequestMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.RequestVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *SearchRequest) GetBody() *SearchRequest_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *SearchRequest) SetBody(v *SearchRequest_Body) {
	x.Body = v
}
func (x *SearchRequest) GetMetaHeader() *grpc1.RequestMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *SearchRequest) SetMetaHeader(v *grpc1.RequestMetaHeader) {
	x.MetaHeader = v
}
func (x *SearchRequest) GetVerifyHeader() *grpc1.RequestVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *SearchRequest) SetVerifyHeader(v *grpc1.RequestVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *SearchRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *SearchRequest) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *SearchRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *SearchRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *SearchRequest_Body
				f = new(SearchRequest_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.RequestMetaHeader
				f = new(grpc1.RequestMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.RequestVerificationHeader
				f = new(grpc1.RequestVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type SearchResponse_Body struct {
	IdList []grpc.ObjectID `json:"idList"`
}

var (
	_ encoding.ProtoMarshaler   = (*SearchResponse_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*SearchResponse_Body)(nil)
	_ json.Marshaler            = (*SearchResponse_Body)(nil)
	_ json.Unmarshaler          = (*SearchResponse_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *SearchResponse_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	for i := range x.IdList {
		size += proto.NestedStructureSizeUnchecked(1, &x.IdList[i])
	}
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *SearchResponse_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *SearchResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	for i := range x.IdList {
		x.IdList[i].EmitProtobuf(mm.AppendMessage(1))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *SearchResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "SearchResponse_Body")
		}
		switch fc.FieldNum {
		case 1: // IdList
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "IdList")
			}
			x.IdList = append(x.IdList, grpc.ObjectID{})
			ff := &x.IdList[len(x.IdList)-1]
			if err := ff.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *SearchResponse_Body) GetIdList() []grpc.ObjectID {
	if x != nil {
		return x.IdList
	}
	return nil
}
func (x *SearchResponse_Body) SetIdList(v []grpc.ObjectID) {
	x.IdList = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *SearchResponse_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *SearchResponse_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if len(x.IdList) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"idList\":"
			out.RawString(prefix)
			out.RawByte('[')
			for i := range x.IdList {
				if i != 0 {
					out.RawByte(',')
				}
				x.IdList[i].MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *SearchResponse_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *SearchResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "idList":
			{
				var f grpc.ObjectID
				var list []grpc.ObjectID
				in.Delim('[')
				for !in.IsDelim(']') {
					f = grpc.ObjectID{}
					f.UnmarshalEasyJSON(in)
					list = append(list, f)
					in.WantComma()
				}
				x.IdList = list
				in.Delim(']')
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type SearchResponse struct {
	Body         *SearchResponse_Body              `json:"body"`
	MetaHeader   *grpc1.ResponseMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.ResponseVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*SearchResponse)(nil)
	_ encoding.ProtoUnmarshaler = (*SearchResponse)(nil)
	_ json.Marshaler            = (*SearchResponse)(nil)
	_ json.Unmarshaler          = (*SearchResponse)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *SearchResponse) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *SearchResponse) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *SearchResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *SearchResponse) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *SearchResponse) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *SearchResponse) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "SearchResponse")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(SearchResponse_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.ResponseMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.ResponseVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *SearchResponse) GetBody() *SearchResponse_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *SearchResponse) SetBody(v *SearchResponse_Body) {
	x.Body = v
}
func (x *SearchResponse) GetMetaHeader() *grpc1.ResponseMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *SearchResponse) SetMetaHeader(v *grpc1.ResponseMetaHeader) {
	x.MetaHeader = v
}
func (x *SearchResponse) GetVerifyHeader() *grpc1.ResponseVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *SearchResponse) SetVerifyHeader(v *grpc1.ResponseVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *SearchResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *SearchResponse) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *SearchResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *SearchResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *SearchResponse_Body
				f = new(SearchResponse_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.ResponseMetaHeader
				f = new(grpc1.ResponseMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.ResponseVerificationHeader
				f = new(grpc1.ResponseVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type Range struct {
	Offset uint64 `json:"offset"`
	Length uint64 `json:"length"`
}

var (
	_ encoding.ProtoMarshaler   = (*Range)(nil)
	_ encoding.ProtoUnmarshaler = (*Range)(nil)
	_ json.Marshaler            = (*Range)(nil)
	_ json.Unmarshaler          = (*Range)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *Range) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.UInt64Size(1, x.Offset)
	size += proto.UInt64Size(2, x.Length)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *Range) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *Range) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Offset != 0 {
		mm.AppendUint64(1, x.Offset)
	}
	if x.Length != 0 {
		mm.AppendUint64(2, x.Length)
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *Range) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "Range")
		}
		switch fc.FieldNum {
		case 1: // Offset
			data, ok := fc.Uint64()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Offset")
			}
			x.Offset = data
		case 2: // Length
			data, ok := fc.Uint64()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Length")
			}
			x.Length = data
		}
	}
	return nil
}
func (x *Range) GetOffset() uint64 {
	if x != nil {
		return x.Offset
	}
	return 0
}
func (x *Range) SetOffset(v uint64) {
	x.Offset = v
}
func (x *Range) GetLength() uint64 {
	if x != nil {
		return x.Length
	}
	return 0
}
func (x *Range) SetLength(v uint64) {
	x.Length = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *Range) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *Range) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Offset != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"offset\":"
			out.RawString(prefix)
			out.Uint64(x.Offset)
		}
	}
	{
		if x.Length != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"length\":"
			out.RawString(prefix)
			out.Uint64(x.Length)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *Range) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *Range) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "offset":
			{
				var f uint64
				f = in.Uint64()
				x.Offset = f
			}
		case "length":
			{
				var f uint64
				f = in.Uint64()
				x.Length = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type GetRangeRequest_Body struct {
	Address *grpc.Address `json:"address"`
	Range   *Range        `json:"range"`
	Raw     bool          `json:"raw"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetRangeRequest_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*GetRangeRequest_Body)(nil)
	_ json.Marshaler            = (*GetRangeRequest_Body)(nil)
	_ json.Unmarshaler          = (*GetRangeRequest_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetRangeRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Address)
	size += proto.NestedStructureSize(2, x.Range)
	size += proto.BoolSize(3, x.Raw)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetRangeRequest_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetRangeRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Address != nil {
		x.Address.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.Range != nil {
		x.Range.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.Raw {
		mm.AppendBool(3, x.Raw)
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetRangeRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetRangeRequest_Body")
		}
		switch fc.FieldNum {
		case 1: // Address
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Address")
			}
			x.Address = new(grpc.Address)
			if err := x.Address.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // Range
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Range")
			}
			x.Range = new(Range)
			if err := x.Range.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // Raw
			data, ok := fc.Bool()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Raw")
			}
			x.Raw = data
		}
	}
	return nil
}
func (x *GetRangeRequest_Body) GetAddress() *grpc.Address {
	if x != nil {
		return x.Address
	}
	return nil
}
func (x *GetRangeRequest_Body) SetAddress(v *grpc.Address) {
	x.Address = v
}
func (x *GetRangeRequest_Body) GetRange() *Range {
	if x != nil {
		return x.Range
	}
	return nil
}
func (x *GetRangeRequest_Body) SetRange(v *Range) {
	x.Range = v
}
func (x *GetRangeRequest_Body) GetRaw() bool {
	if x != nil {
		return x.Raw
	}
	return false
}
func (x *GetRangeRequest_Body) SetRaw(v bool) {
	x.Raw = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetRangeRequest_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetRangeRequest_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Address != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"address\":"
			out.RawString(prefix)
			x.Address.MarshalEasyJSON(out)
		}
	}
	{
		if x.Range != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"range\":"
			out.RawString(prefix)
			x.Range.MarshalEasyJSON(out)
		}
	}
	{
		if x.Raw {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"raw\":"
			out.RawString(prefix)
			out.Bool(x.Raw)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetRangeRequest_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetRangeRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "address":
			{
				var f *grpc.Address
				f = new(grpc.Address)
				f.UnmarshalEasyJSON(in)
				x.Address = f
			}
		case "range":
			{
				var f *Range
				f = new(Range)
				f.UnmarshalEasyJSON(in)
				x.Range = f
			}
		case "raw":
			{
				var f bool
				f = in.Bool()
				x.Raw = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type GetRangeRequest struct {
	Body         *GetRangeRequest_Body            `json:"body"`
	MetaHeader   *grpc1.RequestMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.RequestVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetRangeRequest)(nil)
	_ encoding.ProtoUnmarshaler = (*GetRangeRequest)(nil)
	_ json.Marshaler            = (*GetRangeRequest)(nil)
	_ json.Unmarshaler          = (*GetRangeRequest)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetRangeRequest) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *GetRangeRequest) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *GetRangeRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetRangeRequest) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetRangeRequest) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetRangeRequest) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetRangeRequest")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(GetRangeRequest_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.RequestMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.RequestVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *GetRangeRequest) GetBody() *GetRangeRequest_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *GetRangeRequest) SetBody(v *GetRangeRequest_Body) {
	x.Body = v
}
func (x *GetRangeRequest) GetMetaHeader() *grpc1.RequestMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *GetRangeRequest) SetMetaHeader(v *grpc1.RequestMetaHeader) {
	x.MetaHeader = v
}
func (x *GetRangeRequest) GetVerifyHeader() *grpc1.RequestVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *GetRangeRequest) SetVerifyHeader(v *grpc1.RequestVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetRangeRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetRangeRequest) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetRangeRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetRangeRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *GetRangeRequest_Body
				f = new(GetRangeRequest_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.RequestMetaHeader
				f = new(grpc1.RequestMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.RequestVerificationHeader
				f = new(grpc1.RequestVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type GetRangeResponse_Body struct {
	RangePart isGetRangeResponse_Body_RangePart
}

var (
	_ encoding.ProtoMarshaler   = (*GetRangeResponse_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*GetRangeResponse_Body)(nil)
	_ json.Marshaler            = (*GetRangeResponse_Body)(nil)
	_ json.Unmarshaler          = (*GetRangeResponse_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetRangeResponse_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	if inner, ok := x.RangePart.(*GetRangeResponse_Body_Chunk); ok {
		size += proto.BytesSize(1, inner.Chunk)
	}
	if inner, ok := x.RangePart.(*GetRangeResponse_Body_SplitInfo); ok {
		size += proto.NestedStructureSize(2, inner.SplitInfo)
	}
	if inner, ok := x.RangePart.(*GetRangeResponse_Body_EcInfo); ok {
		size += proto.NestedStructureSize(3, inner.EcInfo)
	}
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetRangeResponse_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetRangeResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if inner, ok := x.RangePart.(*GetRangeResponse_Body_Chunk); ok {
		if len(inner.Chunk) != 0 {
			mm.AppendBytes(1, inner.Chunk)
		}
	}
	if inner, ok := x.RangePart.(*GetRangeResponse_Body_SplitInfo); ok {
		if inner.SplitInfo != nil {
			inner.SplitInfo.EmitProtobuf(mm.AppendMessage(2))
		}
	}
	if inner, ok := x.RangePart.(*GetRangeResponse_Body_EcInfo); ok {
		if inner.EcInfo != nil {
			inner.EcInfo.EmitProtobuf(mm.AppendMessage(3))
		}
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetRangeResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetRangeResponse_Body")
		}
		switch fc.FieldNum {
		case 1: // Chunk
			data, ok := fc.Bytes()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Chunk")
			}
			x.RangePart = &GetRangeResponse_Body_Chunk{Chunk: data}
		case 2: // SplitInfo
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "SplitInfo")
			}
			oneofField := &GetRangeResponse_Body_SplitInfo{SplitInfo: new(SplitInfo)}
			if err := oneofField.SplitInfo.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
			x.RangePart = oneofField
		case 3: // EcInfo
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "EcInfo")
			}
			oneofField := &GetRangeResponse_Body_EcInfo{EcInfo: new(ECInfo)}
			if err := oneofField.EcInfo.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
			x.RangePart = oneofField
		}
	}
	return nil
}
func (x *GetRangeResponse_Body) GetRangePart() isGetRangeResponse_Body_RangePart {
	if x != nil {
		return x.RangePart
	}
	return nil
}
func (x *GetRangeResponse_Body) SetRangePart(v isGetRangeResponse_Body_RangePart) {
	x.RangePart = v
}
func (x *GetRangeResponse_Body) GetChunk() []byte {
	if xx, ok := x.GetRangePart().(*GetRangeResponse_Body_Chunk); ok {
		return xx.Chunk
	}
	return nil
}
func (x *GetRangeResponse_Body) SetChunk(v *GetRangeResponse_Body_Chunk) {
	x.RangePart = v
}
func (x *GetRangeResponse_Body_Chunk) GetChunk() []byte {
	if x != nil {
		return x.Chunk
	}
	return nil
}
func (x *GetRangeResponse_Body_Chunk) SetChunk(v []byte) {
	x.Chunk = v
}
func (x *GetRangeResponse_Body) GetSplitInfo() *SplitInfo {
	if xx, ok := x.GetRangePart().(*GetRangeResponse_Body_SplitInfo); ok {
		return xx.SplitInfo
	}
	return nil
}
func (x *GetRangeResponse_Body) SetSplitInfo(v *SplitInfo) {
	x.RangePart = &GetRangeResponse_Body_SplitInfo{SplitInfo: v}
}
func (x *GetRangeResponse_Body) GetEcInfo() *ECInfo {
	if xx, ok := x.GetRangePart().(*GetRangeResponse_Body_EcInfo); ok {
		return xx.EcInfo
	}
	return nil
}
func (x *GetRangeResponse_Body) SetEcInfo(v *ECInfo) {
	x.RangePart = &GetRangeResponse_Body_EcInfo{EcInfo: v}
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetRangeResponse_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetRangeResponse_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	switch xx := x.RangePart.(type) {
	case *GetRangeResponse_Body_Chunk:
		{
			if len(xx.Chunk) != 0 {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"chunk\":"
				out.RawString(prefix)
				out.Base64Bytes(xx.Chunk)
			}
		}
	case *GetRangeResponse_Body_SplitInfo:
		{
			if xx.SplitInfo != nil {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"splitInfo\":"
				out.RawString(prefix)
				xx.SplitInfo.MarshalEasyJSON(out)
			}
		}
	case *GetRangeResponse_Body_EcInfo:
		{
			if xx.EcInfo != nil {
				if !first {
					out.RawByte(',')
				} else {
					first = false
				}
				const prefix string = "\"ecInfo\":"
				out.RawString(prefix)
				xx.EcInfo.MarshalEasyJSON(out)
			}
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetRangeResponse_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetRangeResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "chunk":
			xx := new(GetRangeResponse_Body_Chunk)
			x.RangePart = xx
			{
				var f []byte
				f = in.Bytes()
				xx.Chunk = f
			}
		case "splitInfo":
			xx := new(GetRangeResponse_Body_SplitInfo)
			x.RangePart = xx
			{
				var f *SplitInfo
				f = new(SplitInfo)
				f.UnmarshalEasyJSON(in)
				xx.SplitInfo = f
			}
		case "ecInfo":
			xx := new(GetRangeResponse_Body_EcInfo)
			x.RangePart = xx
			{
				var f *ECInfo
				f = new(ECInfo)
				f.UnmarshalEasyJSON(in)
				xx.EcInfo = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type isGetRangeResponse_Body_RangePart interface {
	isGetRangeResponse_Body_RangePart()
}

type GetRangeResponse_Body_Chunk struct {
	Chunk []byte
}

type GetRangeResponse_Body_SplitInfo struct {
	SplitInfo *SplitInfo
}

type GetRangeResponse_Body_EcInfo struct {
	EcInfo *ECInfo
}

func (*GetRangeResponse_Body_Chunk) isGetRangeResponse_Body_RangePart() {}

func (*GetRangeResponse_Body_SplitInfo) isGetRangeResponse_Body_RangePart() {}

func (*GetRangeResponse_Body_EcInfo) isGetRangeResponse_Body_RangePart() {}

type GetRangeResponse struct {
	Body         *GetRangeResponse_Body            `json:"body"`
	MetaHeader   *grpc1.ResponseMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.ResponseVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetRangeResponse)(nil)
	_ encoding.ProtoUnmarshaler = (*GetRangeResponse)(nil)
	_ json.Marshaler            = (*GetRangeResponse)(nil)
	_ json.Unmarshaler          = (*GetRangeResponse)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetRangeResponse) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *GetRangeResponse) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *GetRangeResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetRangeResponse) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetRangeResponse) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetRangeResponse) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetRangeResponse")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(GetRangeResponse_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.ResponseMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.ResponseVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *GetRangeResponse) GetBody() *GetRangeResponse_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *GetRangeResponse) SetBody(v *GetRangeResponse_Body) {
	x.Body = v
}
func (x *GetRangeResponse) GetMetaHeader() *grpc1.ResponseMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *GetRangeResponse) SetMetaHeader(v *grpc1.ResponseMetaHeader) {
	x.MetaHeader = v
}
func (x *GetRangeResponse) GetVerifyHeader() *grpc1.ResponseVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *GetRangeResponse) SetVerifyHeader(v *grpc1.ResponseVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetRangeResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetRangeResponse) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetRangeResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetRangeResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *GetRangeResponse_Body
				f = new(GetRangeResponse_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.ResponseMetaHeader
				f = new(grpc1.ResponseMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.ResponseVerificationHeader
				f = new(grpc1.ResponseVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type GetRangeHashRequest_Body struct {
	Address *grpc.Address     `json:"address"`
	Ranges  []Range           `json:"ranges"`
	Salt    []byte            `json:"salt"`
	Type    grpc.ChecksumType `json:"type"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetRangeHashRequest_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*GetRangeHashRequest_Body)(nil)
	_ json.Marshaler            = (*GetRangeHashRequest_Body)(nil)
	_ json.Unmarshaler          = (*GetRangeHashRequest_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetRangeHashRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Address)
	for i := range x.Ranges {
		size += proto.NestedStructureSizeUnchecked(2, &x.Ranges[i])
	}
	size += proto.BytesSize(3, x.Salt)
	size += proto.EnumSize(4, int32(x.Type))
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetRangeHashRequest_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetRangeHashRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Address != nil {
		x.Address.EmitProtobuf(mm.AppendMessage(1))
	}
	for i := range x.Ranges {
		x.Ranges[i].EmitProtobuf(mm.AppendMessage(2))
	}
	if len(x.Salt) != 0 {
		mm.AppendBytes(3, x.Salt)
	}
	if int32(x.Type) != 0 {
		mm.AppendInt32(4, int32(x.Type))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetRangeHashRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetRangeHashRequest_Body")
		}
		switch fc.FieldNum {
		case 1: // Address
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Address")
			}
			x.Address = new(grpc.Address)
			if err := x.Address.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // Ranges
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Ranges")
			}
			x.Ranges = append(x.Ranges, Range{})
			ff := &x.Ranges[len(x.Ranges)-1]
			if err := ff.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // Salt
			data, ok := fc.Bytes()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Salt")
			}
			x.Salt = data
		case 4: // Type
			data, ok := fc.Int32()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Type")
			}
			x.Type = grpc.ChecksumType(data)
		}
	}
	return nil
}
func (x *GetRangeHashRequest_Body) GetAddress() *grpc.Address {
	if x != nil {
		return x.Address
	}
	return nil
}
func (x *GetRangeHashRequest_Body) SetAddress(v *grpc.Address) {
	x.Address = v
}
func (x *GetRangeHashRequest_Body) GetRanges() []Range {
	if x != nil {
		return x.Ranges
	}
	return nil
}
func (x *GetRangeHashRequest_Body) SetRanges(v []Range) {
	x.Ranges = v
}
func (x *GetRangeHashRequest_Body) GetSalt() []byte {
	if x != nil {
		return x.Salt
	}
	return nil
}
func (x *GetRangeHashRequest_Body) SetSalt(v []byte) {
	x.Salt = v
}
func (x *GetRangeHashRequest_Body) GetType() grpc.ChecksumType {
	if x != nil {
		return x.Type
	}
	return 0
}
func (x *GetRangeHashRequest_Body) SetType(v grpc.ChecksumType) {
	x.Type = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetRangeHashRequest_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetRangeHashRequest_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Address != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"address\":"
			out.RawString(prefix)
			x.Address.MarshalEasyJSON(out)
		}
	}
	{
		if len(x.Ranges) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"ranges\":"
			out.RawString(prefix)
			out.RawByte('[')
			for i := range x.Ranges {
				if i != 0 {
					out.RawByte(',')
				}
				x.Ranges[i].MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	{
		if len(x.Salt) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"salt\":"
			out.RawString(prefix)
			out.Base64Bytes(x.Salt)
		}
	}
	{
		if x.Type != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"type\":"
			out.RawString(prefix)
			v := int32(x.Type)
			if vv, ok := grpc.ChecksumType_name[v]; ok {
				out.String(vv)
			} else {
				out.Int32(v)
			}
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetRangeHashRequest_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetRangeHashRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "address":
			{
				var f *grpc.Address
				f = new(grpc.Address)
				f.UnmarshalEasyJSON(in)
				x.Address = f
			}
		case "ranges":
			{
				var f Range
				var list []Range
				in.Delim('[')
				for !in.IsDelim(']') {
					f = Range{}
					f.UnmarshalEasyJSON(in)
					list = append(list, f)
					in.WantComma()
				}
				x.Ranges = list
				in.Delim(']')
			}
		case "salt":
			{
				var f []byte
				f = in.Bytes()
				x.Salt = f
			}
		case "type":
			{
				var f grpc.ChecksumType
				var parsedValue grpc.ChecksumType
				switch v := in.Interface().(type) {
				case string:
					if vv, ok := grpc.ChecksumType_value[v]; ok {
						parsedValue = grpc.ChecksumType(vv)
						break
					}
					vv, err := strconv.ParseInt(v, 10, 32)
					if err != nil {
						in.AddError(err)
						return
					}
					parsedValue = grpc.ChecksumType(vv)
				case float64:
					parsedValue = grpc.ChecksumType(v)
				}
				f = parsedValue
				x.Type = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type GetRangeHashRequest struct {
	Body         *GetRangeHashRequest_Body        `json:"body"`
	MetaHeader   *grpc1.RequestMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.RequestVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetRangeHashRequest)(nil)
	_ encoding.ProtoUnmarshaler = (*GetRangeHashRequest)(nil)
	_ json.Marshaler            = (*GetRangeHashRequest)(nil)
	_ json.Unmarshaler          = (*GetRangeHashRequest)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetRangeHashRequest) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *GetRangeHashRequest) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *GetRangeHashRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetRangeHashRequest) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetRangeHashRequest) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetRangeHashRequest) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetRangeHashRequest")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(GetRangeHashRequest_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.RequestMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.RequestVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *GetRangeHashRequest) GetBody() *GetRangeHashRequest_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *GetRangeHashRequest) SetBody(v *GetRangeHashRequest_Body) {
	x.Body = v
}
func (x *GetRangeHashRequest) GetMetaHeader() *grpc1.RequestMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *GetRangeHashRequest) SetMetaHeader(v *grpc1.RequestMetaHeader) {
	x.MetaHeader = v
}
func (x *GetRangeHashRequest) GetVerifyHeader() *grpc1.RequestVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *GetRangeHashRequest) SetVerifyHeader(v *grpc1.RequestVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetRangeHashRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetRangeHashRequest) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetRangeHashRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetRangeHashRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *GetRangeHashRequest_Body
				f = new(GetRangeHashRequest_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.RequestMetaHeader
				f = new(grpc1.RequestMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.RequestVerificationHeader
				f = new(grpc1.RequestVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type GetRangeHashResponse_Body struct {
	Type     grpc.ChecksumType `json:"type"`
	HashList [][]byte          `json:"hashList"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetRangeHashResponse_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*GetRangeHashResponse_Body)(nil)
	_ json.Marshaler            = (*GetRangeHashResponse_Body)(nil)
	_ json.Unmarshaler          = (*GetRangeHashResponse_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetRangeHashResponse_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.EnumSize(1, int32(x.Type))
	size += proto.RepeatedBytesSize(2, x.HashList)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetRangeHashResponse_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetRangeHashResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if int32(x.Type) != 0 {
		mm.AppendInt32(1, int32(x.Type))
	}
	for j := range x.HashList {
		mm.AppendBytes(2, x.HashList[j])
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetRangeHashResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetRangeHashResponse_Body")
		}
		switch fc.FieldNum {
		case 1: // Type
			data, ok := fc.Int32()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Type")
			}
			x.Type = grpc.ChecksumType(data)
		case 2: // HashList
			data, ok := fc.Bytes()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "HashList")
			}
			x.HashList = append(x.HashList, data)
		}
	}
	return nil
}
func (x *GetRangeHashResponse_Body) GetType() grpc.ChecksumType {
	if x != nil {
		return x.Type
	}
	return 0
}
func (x *GetRangeHashResponse_Body) SetType(v grpc.ChecksumType) {
	x.Type = v
}
func (x *GetRangeHashResponse_Body) GetHashList() [][]byte {
	if x != nil {
		return x.HashList
	}
	return nil
}
func (x *GetRangeHashResponse_Body) SetHashList(v [][]byte) {
	x.HashList = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetRangeHashResponse_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetRangeHashResponse_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Type != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"type\":"
			out.RawString(prefix)
			v := int32(x.Type)
			if vv, ok := grpc.ChecksumType_name[v]; ok {
				out.String(vv)
			} else {
				out.Int32(v)
			}
		}
	}
	{
		if len(x.HashList) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"hashList\":"
			out.RawString(prefix)
			out.RawByte('[')
			for i := range x.HashList {
				if i != 0 {
					out.RawByte(',')
				}
				out.Base64Bytes(x.HashList[i])
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetRangeHashResponse_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetRangeHashResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "type":
			{
				var f grpc.ChecksumType
				var parsedValue grpc.ChecksumType
				switch v := in.Interface().(type) {
				case string:
					if vv, ok := grpc.ChecksumType_value[v]; ok {
						parsedValue = grpc.ChecksumType(vv)
						break
					}
					vv, err := strconv.ParseInt(v, 10, 32)
					if err != nil {
						in.AddError(err)
						return
					}
					parsedValue = grpc.ChecksumType(vv)
				case float64:
					parsedValue = grpc.ChecksumType(v)
				}
				f = parsedValue
				x.Type = f
			}
		case "hashList":
			{
				var f []byte
				var list [][]byte
				in.Delim('[')
				for !in.IsDelim(']') {
					f = in.Bytes()
					list = append(list, f)
					in.WantComma()
				}
				x.HashList = list
				in.Delim(']')
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type GetRangeHashResponse struct {
	Body         *GetRangeHashResponse_Body        `json:"body"`
	MetaHeader   *grpc1.ResponseMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.ResponseVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*GetRangeHashResponse)(nil)
	_ encoding.ProtoUnmarshaler = (*GetRangeHashResponse)(nil)
	_ json.Marshaler            = (*GetRangeHashResponse)(nil)
	_ json.Unmarshaler          = (*GetRangeHashResponse)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetRangeHashResponse) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *GetRangeHashResponse) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *GetRangeHashResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *GetRangeHashResponse) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *GetRangeHashResponse) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *GetRangeHashResponse) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "GetRangeHashResponse")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(GetRangeHashResponse_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.ResponseMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.ResponseVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *GetRangeHashResponse) GetBody() *GetRangeHashResponse_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *GetRangeHashResponse) SetBody(v *GetRangeHashResponse_Body) {
	x.Body = v
}
func (x *GetRangeHashResponse) GetMetaHeader() *grpc1.ResponseMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *GetRangeHashResponse) SetMetaHeader(v *grpc1.ResponseMetaHeader) {
	x.MetaHeader = v
}
func (x *GetRangeHashResponse) GetVerifyHeader() *grpc1.ResponseVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *GetRangeHashResponse) SetVerifyHeader(v *grpc1.ResponseVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *GetRangeHashResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *GetRangeHashResponse) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *GetRangeHashResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *GetRangeHashResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *GetRangeHashResponse_Body
				f = new(GetRangeHashResponse_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.ResponseMetaHeader
				f = new(grpc1.ResponseMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.ResponseVerificationHeader
				f = new(grpc1.ResponseVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PutSingleRequest_Body struct {
	Object       *Object  `json:"object"`
	CopiesNumber []uint32 `json:"copiesNumber"`
}

var (
	_ encoding.ProtoMarshaler   = (*PutSingleRequest_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*PutSingleRequest_Body)(nil)
	_ json.Marshaler            = (*PutSingleRequest_Body)(nil)
	_ json.Unmarshaler          = (*PutSingleRequest_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PutSingleRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	var n int
	size += proto.NestedStructureSize(1, x.Object)
	n, _ = proto.RepeatedUInt32Size(2, x.CopiesNumber)
	size += n
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PutSingleRequest_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PutSingleRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Object != nil {
		x.Object.EmitProtobuf(mm.AppendMessage(1))
	}
	if len(x.CopiesNumber) != 0 {
		mm.AppendUint32s(2, x.CopiesNumber)
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PutSingleRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PutSingleRequest_Body")
		}
		switch fc.FieldNum {
		case 1: // Object
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Object")
			}
			x.Object = new(Object)
			if err := x.Object.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // CopiesNumber
			data, ok := fc.UnpackUint32s(nil)
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "CopiesNumber")
			}
			x.CopiesNumber = data
		}
	}
	return nil
}
func (x *PutSingleRequest_Body) GetObject() *Object {
	if x != nil {
		return x.Object
	}
	return nil
}
func (x *PutSingleRequest_Body) SetObject(v *Object) {
	x.Object = v
}
func (x *PutSingleRequest_Body) GetCopiesNumber() []uint32 {
	if x != nil {
		return x.CopiesNumber
	}
	return nil
}
func (x *PutSingleRequest_Body) SetCopiesNumber(v []uint32) {
	x.CopiesNumber = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PutSingleRequest_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PutSingleRequest_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Object != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"object\":"
			out.RawString(prefix)
			x.Object.MarshalEasyJSON(out)
		}
	}
	{
		if len(x.CopiesNumber) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"copiesNumber\":"
			out.RawString(prefix)
			out.RawByte('[')
			for i := range x.CopiesNumber {
				if i != 0 {
					out.RawByte(',')
				}
				out.Uint32(x.CopiesNumber[i])
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PutSingleRequest_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PutSingleRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "object":
			{
				var f *Object
				f = new(Object)
				f.UnmarshalEasyJSON(in)
				x.Object = f
			}
		case "copiesNumber":
			{
				var f uint32
				var list []uint32
				in.Delim('[')
				for !in.IsDelim(']') {
					f = in.Uint32()
					list = append(list, f)
					in.WantComma()
				}
				x.CopiesNumber = list
				in.Delim(']')
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PutSingleRequest struct {
	Body         *PutSingleRequest_Body           `json:"body"`
	MetaHeader   *grpc1.RequestMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.RequestVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*PutSingleRequest)(nil)
	_ encoding.ProtoUnmarshaler = (*PutSingleRequest)(nil)
	_ json.Marshaler            = (*PutSingleRequest)(nil)
	_ json.Unmarshaler          = (*PutSingleRequest)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PutSingleRequest) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *PutSingleRequest) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *PutSingleRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PutSingleRequest) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PutSingleRequest) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PutSingleRequest) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PutSingleRequest")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(PutSingleRequest_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.RequestMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.RequestVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *PutSingleRequest) GetBody() *PutSingleRequest_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *PutSingleRequest) SetBody(v *PutSingleRequest_Body) {
	x.Body = v
}
func (x *PutSingleRequest) GetMetaHeader() *grpc1.RequestMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *PutSingleRequest) SetMetaHeader(v *grpc1.RequestMetaHeader) {
	x.MetaHeader = v
}
func (x *PutSingleRequest) GetVerifyHeader() *grpc1.RequestVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *PutSingleRequest) SetVerifyHeader(v *grpc1.RequestVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PutSingleRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PutSingleRequest) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PutSingleRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PutSingleRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *PutSingleRequest_Body
				f = new(PutSingleRequest_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.RequestMetaHeader
				f = new(grpc1.RequestMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.RequestVerificationHeader
				f = new(grpc1.RequestVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PutSingleResponse_Body struct {
}

var (
	_ encoding.ProtoMarshaler   = (*PutSingleResponse_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*PutSingleResponse_Body)(nil)
	_ json.Marshaler            = (*PutSingleResponse_Body)(nil)
	_ json.Unmarshaler          = (*PutSingleResponse_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PutSingleResponse_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PutSingleResponse_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PutSingleResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PutSingleResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PutSingleResponse_Body")
		}
		switch fc.FieldNum {
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PutSingleResponse_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PutSingleResponse_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	out.RawByte('{')
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PutSingleResponse_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PutSingleResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PutSingleResponse struct {
	Body         *PutSingleResponse_Body           `json:"body"`
	MetaHeader   *grpc1.ResponseMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.ResponseVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*PutSingleResponse)(nil)
	_ encoding.ProtoUnmarshaler = (*PutSingleResponse)(nil)
	_ json.Marshaler            = (*PutSingleResponse)(nil)
	_ json.Unmarshaler          = (*PutSingleResponse)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PutSingleResponse) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *PutSingleResponse) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *PutSingleResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PutSingleResponse) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PutSingleResponse) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PutSingleResponse) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PutSingleResponse")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(PutSingleResponse_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.ResponseMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.ResponseVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *PutSingleResponse) GetBody() *PutSingleResponse_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *PutSingleResponse) SetBody(v *PutSingleResponse_Body) {
	x.Body = v
}
func (x *PutSingleResponse) GetMetaHeader() *grpc1.ResponseMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *PutSingleResponse) SetMetaHeader(v *grpc1.ResponseMetaHeader) {
	x.MetaHeader = v
}
func (x *PutSingleResponse) GetVerifyHeader() *grpc1.ResponseVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *PutSingleResponse) SetVerifyHeader(v *grpc1.ResponseVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PutSingleResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PutSingleResponse) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PutSingleResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PutSingleResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *PutSingleResponse_Body
				f = new(PutSingleResponse_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.ResponseMetaHeader
				f = new(grpc1.ResponseMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.ResponseVerificationHeader
				f = new(grpc1.ResponseVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PatchRequest_Body_Patch struct {
	SourceRange *Range `json:"sourceRange"`
	Chunk       []byte `json:"chunk"`
}

var (
	_ encoding.ProtoMarshaler   = (*PatchRequest_Body_Patch)(nil)
	_ encoding.ProtoUnmarshaler = (*PatchRequest_Body_Patch)(nil)
	_ json.Marshaler            = (*PatchRequest_Body_Patch)(nil)
	_ json.Unmarshaler          = (*PatchRequest_Body_Patch)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PatchRequest_Body_Patch) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.SourceRange)
	size += proto.BytesSize(2, x.Chunk)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PatchRequest_Body_Patch) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PatchRequest_Body_Patch) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.SourceRange != nil {
		x.SourceRange.EmitProtobuf(mm.AppendMessage(1))
	}
	if len(x.Chunk) != 0 {
		mm.AppendBytes(2, x.Chunk)
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PatchRequest_Body_Patch) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PatchRequest_Body_Patch")
		}
		switch fc.FieldNum {
		case 1: // SourceRange
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "SourceRange")
			}
			x.SourceRange = new(Range)
			if err := x.SourceRange.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // Chunk
			data, ok := fc.Bytes()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Chunk")
			}
			x.Chunk = data
		}
	}
	return nil
}
func (x *PatchRequest_Body_Patch) GetSourceRange() *Range {
	if x != nil {
		return x.SourceRange
	}
	return nil
}
func (x *PatchRequest_Body_Patch) SetSourceRange(v *Range) {
	x.SourceRange = v
}
func (x *PatchRequest_Body_Patch) GetChunk() []byte {
	if x != nil {
		return x.Chunk
	}
	return nil
}
func (x *PatchRequest_Body_Patch) SetChunk(v []byte) {
	x.Chunk = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PatchRequest_Body_Patch) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PatchRequest_Body_Patch) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.SourceRange != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"sourceRange\":"
			out.RawString(prefix)
			x.SourceRange.MarshalEasyJSON(out)
		}
	}
	{
		if len(x.Chunk) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"chunk\":"
			out.RawString(prefix)
			out.Base64Bytes(x.Chunk)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PatchRequest_Body_Patch) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PatchRequest_Body_Patch) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "sourceRange":
			{
				var f *Range
				f = new(Range)
				f.UnmarshalEasyJSON(in)
				x.SourceRange = f
			}
		case "chunk":
			{
				var f []byte
				f = in.Bytes()
				x.Chunk = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PatchRequest_Body struct {
	Address           *grpc.Address            `json:"address"`
	NewAttributes     []Header_Attribute       `json:"newAttributes"`
	ReplaceAttributes bool                     `json:"replaceAttributes"`
	Patch             *PatchRequest_Body_Patch `json:"patch"`
}

var (
	_ encoding.ProtoMarshaler   = (*PatchRequest_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*PatchRequest_Body)(nil)
	_ json.Marshaler            = (*PatchRequest_Body)(nil)
	_ json.Unmarshaler          = (*PatchRequest_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PatchRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Address)
	for i := range x.NewAttributes {
		size += proto.NestedStructureSizeUnchecked(2, &x.NewAttributes[i])
	}
	size += proto.BoolSize(3, x.ReplaceAttributes)
	size += proto.NestedStructureSize(4, x.Patch)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PatchRequest_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PatchRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Address != nil {
		x.Address.EmitProtobuf(mm.AppendMessage(1))
	}
	for i := range x.NewAttributes {
		x.NewAttributes[i].EmitProtobuf(mm.AppendMessage(2))
	}
	if x.ReplaceAttributes {
		mm.AppendBool(3, x.ReplaceAttributes)
	}
	if x.Patch != nil {
		x.Patch.EmitProtobuf(mm.AppendMessage(4))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PatchRequest_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PatchRequest_Body")
		}
		switch fc.FieldNum {
		case 1: // Address
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Address")
			}
			x.Address = new(grpc.Address)
			if err := x.Address.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // NewAttributes
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "NewAttributes")
			}
			x.NewAttributes = append(x.NewAttributes, Header_Attribute{})
			ff := &x.NewAttributes[len(x.NewAttributes)-1]
			if err := ff.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // ReplaceAttributes
			data, ok := fc.Bool()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "ReplaceAttributes")
			}
			x.ReplaceAttributes = data
		case 4: // Patch
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Patch")
			}
			x.Patch = new(PatchRequest_Body_Patch)
			if err := x.Patch.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *PatchRequest_Body) GetAddress() *grpc.Address {
	if x != nil {
		return x.Address
	}
	return nil
}
func (x *PatchRequest_Body) SetAddress(v *grpc.Address) {
	x.Address = v
}
func (x *PatchRequest_Body) GetNewAttributes() []Header_Attribute {
	if x != nil {
		return x.NewAttributes
	}
	return nil
}
func (x *PatchRequest_Body) SetNewAttributes(v []Header_Attribute) {
	x.NewAttributes = v
}
func (x *PatchRequest_Body) GetReplaceAttributes() bool {
	if x != nil {
		return x.ReplaceAttributes
	}
	return false
}
func (x *PatchRequest_Body) SetReplaceAttributes(v bool) {
	x.ReplaceAttributes = v
}
func (x *PatchRequest_Body) GetPatch() *PatchRequest_Body_Patch {
	if x != nil {
		return x.Patch
	}
	return nil
}
func (x *PatchRequest_Body) SetPatch(v *PatchRequest_Body_Patch) {
	x.Patch = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PatchRequest_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PatchRequest_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Address != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"address\":"
			out.RawString(prefix)
			x.Address.MarshalEasyJSON(out)
		}
	}
	{
		if len(x.NewAttributes) != 0 {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"newAttributes\":"
			out.RawString(prefix)
			out.RawByte('[')
			for i := range x.NewAttributes {
				if i != 0 {
					out.RawByte(',')
				}
				x.NewAttributes[i].MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	{
		if x.ReplaceAttributes {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"replaceAttributes\":"
			out.RawString(prefix)
			out.Bool(x.ReplaceAttributes)
		}
	}
	{
		if x.Patch != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"patch\":"
			out.RawString(prefix)
			x.Patch.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PatchRequest_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PatchRequest_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "address":
			{
				var f *grpc.Address
				f = new(grpc.Address)
				f.UnmarshalEasyJSON(in)
				x.Address = f
			}
		case "newAttributes":
			{
				var f Header_Attribute
				var list []Header_Attribute
				in.Delim('[')
				for !in.IsDelim(']') {
					f = Header_Attribute{}
					f.UnmarshalEasyJSON(in)
					list = append(list, f)
					in.WantComma()
				}
				x.NewAttributes = list
				in.Delim(']')
			}
		case "replaceAttributes":
			{
				var f bool
				f = in.Bool()
				x.ReplaceAttributes = f
			}
		case "patch":
			{
				var f *PatchRequest_Body_Patch
				f = new(PatchRequest_Body_Patch)
				f.UnmarshalEasyJSON(in)
				x.Patch = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PatchRequest struct {
	Body         *PatchRequest_Body               `json:"body"`
	MetaHeader   *grpc1.RequestMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.RequestVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*PatchRequest)(nil)
	_ encoding.ProtoUnmarshaler = (*PatchRequest)(nil)
	_ json.Marshaler            = (*PatchRequest)(nil)
	_ json.Unmarshaler          = (*PatchRequest)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PatchRequest) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *PatchRequest) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *PatchRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PatchRequest) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PatchRequest) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PatchRequest) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PatchRequest")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(PatchRequest_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.RequestMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.RequestVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *PatchRequest) GetBody() *PatchRequest_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *PatchRequest) SetBody(v *PatchRequest_Body) {
	x.Body = v
}
func (x *PatchRequest) GetMetaHeader() *grpc1.RequestMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *PatchRequest) SetMetaHeader(v *grpc1.RequestMetaHeader) {
	x.MetaHeader = v
}
func (x *PatchRequest) GetVerifyHeader() *grpc1.RequestVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *PatchRequest) SetVerifyHeader(v *grpc1.RequestVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PatchRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PatchRequest) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PatchRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PatchRequest) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *PatchRequest_Body
				f = new(PatchRequest_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.RequestMetaHeader
				f = new(grpc1.RequestMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.RequestVerificationHeader
				f = new(grpc1.RequestVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PatchResponse_Body struct {
	ObjectId *grpc.ObjectID `json:"objectId"`
}

var (
	_ encoding.ProtoMarshaler   = (*PatchResponse_Body)(nil)
	_ encoding.ProtoUnmarshaler = (*PatchResponse_Body)(nil)
	_ json.Marshaler            = (*PatchResponse_Body)(nil)
	_ json.Unmarshaler          = (*PatchResponse_Body)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PatchResponse_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.ObjectId)
	return size
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PatchResponse_Body) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PatchResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.ObjectId != nil {
		x.ObjectId.EmitProtobuf(mm.AppendMessage(1))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PatchResponse_Body) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PatchResponse_Body")
		}
		switch fc.FieldNum {
		case 1: // ObjectId
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "ObjectId")
			}
			x.ObjectId = new(grpc.ObjectID)
			if err := x.ObjectId.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *PatchResponse_Body) GetObjectId() *grpc.ObjectID {
	if x != nil {
		return x.ObjectId
	}
	return nil
}
func (x *PatchResponse_Body) SetObjectId(v *grpc.ObjectID) {
	x.ObjectId = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PatchResponse_Body) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PatchResponse_Body) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.ObjectId != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"objectId\":"
			out.RawString(prefix)
			x.ObjectId.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PatchResponse_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PatchResponse_Body) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "objectId":
			{
				var f *grpc.ObjectID
				f = new(grpc.ObjectID)
				f.UnmarshalEasyJSON(in)
				x.ObjectId = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type PatchResponse struct {
	Body         *PatchResponse_Body               `json:"body"`
	MetaHeader   *grpc1.ResponseMetaHeader         `json:"metaHeader"`
	VerifyHeader *grpc1.ResponseVerificationHeader `json:"verifyHeader"`
}

var (
	_ encoding.ProtoMarshaler   = (*PatchResponse)(nil)
	_ encoding.ProtoUnmarshaler = (*PatchResponse)(nil)
	_ json.Marshaler            = (*PatchResponse)(nil)
	_ json.Unmarshaler          = (*PatchResponse)(nil)
)

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *PatchResponse) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.NestedStructureSize(1, x.Body)
	size += proto.NestedStructureSize(2, x.MetaHeader)
	size += proto.NestedStructureSize(3, x.VerifyHeader)
	return size
}

// ReadSignedData fills buf with signed data of x.
// If buffer length is less than x.SignedDataSize(), new buffer is allocated.
//
// Returns any error encountered which did not allow writing the data completely.
// Otherwise, returns the buffer in which the data is written.
//
// Structures with the same field values have the same signed data.
func (x *PatchResponse) SignedDataSize() int {
	return x.GetBody().StableSize()
}

// SignedDataSize returns size of the request signed data in bytes.
//
// Structures with the same field values have the same signed data size.
func (x *PatchResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *PatchResponse) MarshalProtobuf(dst []byte) []byte {
	m := pool.MarshalerPool.Get()
	defer pool.MarshalerPool.Put(m)
	x.EmitProtobuf(m.MessageMarshaler())
	dst = m.Marshal(dst)
	return dst
}

func (x *PatchResponse) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.Body != nil {
		x.Body.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.MetaHeader != nil {
		x.MetaHeader.EmitProtobuf(mm.AppendMessage(2))
	}
	if x.VerifyHeader != nil {
		x.VerifyHeader.EmitProtobuf(mm.AppendMessage(3))
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *PatchResponse) UnmarshalProtobuf(src []byte) (err error) {
	var fc easyproto.FieldContext
	for len(src) > 0 {
		src, err = fc.NextField(src)
		if err != nil {
			return fmt.Errorf("cannot read next field in %s", "PatchResponse")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(PatchResponse_Body)
			if err := x.Body.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // MetaHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "MetaHeader")
			}
			x.MetaHeader = new(grpc1.ResponseMetaHeader)
			if err := x.MetaHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 3: // VerifyHeader
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "VerifyHeader")
			}
			x.VerifyHeader = new(grpc1.ResponseVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *PatchResponse) GetBody() *PatchResponse_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *PatchResponse) SetBody(v *PatchResponse_Body) {
	x.Body = v
}
func (x *PatchResponse) GetMetaHeader() *grpc1.ResponseMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *PatchResponse) SetMetaHeader(v *grpc1.ResponseMetaHeader) {
	x.MetaHeader = v
}
func (x *PatchResponse) GetVerifyHeader() *grpc1.ResponseVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *PatchResponse) SetVerifyHeader(v *grpc1.ResponseVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *PatchResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *PatchResponse) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if x.Body != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"body\":"
			out.RawString(prefix)
			x.Body.MarshalEasyJSON(out)
		}
	}
	{
		if x.MetaHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"metaHeader\":"
			out.RawString(prefix)
			x.MetaHeader.MarshalEasyJSON(out)
		}
	}
	{
		if x.VerifyHeader != nil {
			if !first {
				out.RawByte(',')
			} else {
				first = false
			}
			const prefix string = "\"verifyHeader\":"
			out.RawString(prefix)
			x.VerifyHeader.MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *PatchResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *PatchResponse) UnmarshalEasyJSON(in *jlexer.Lexer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "body":
			{
				var f *PatchResponse_Body
				f = new(PatchResponse_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *grpc1.ResponseMetaHeader
				f = new(grpc1.ResponseMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *grpc1.ResponseVerificationHeader
				f = new(grpc1.ResponseVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}