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

package session

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

type CreateRequest_Body struct {
	OwnerId    *grpc.OwnerID `json:"ownerId"`
	Expiration uint64        `json:"expiration"`
}

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

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

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *CreateRequest_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 *CreateRequest_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if x.OwnerId != nil {
		x.OwnerId.EmitProtobuf(mm.AppendMessage(1))
	}
	if x.Expiration != 0 {
		mm.AppendUint64(2, x.Expiration)
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *CreateRequest_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", "CreateRequest_Body")
		}
		switch fc.FieldNum {
		case 1: // OwnerId
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "OwnerId")
			}
			x.OwnerId = new(grpc.OwnerID)
			if err := x.OwnerId.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		case 2: // Expiration
			data, ok := fc.Uint64()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Expiration")
			}
			x.Expiration = data
		}
	}
	return nil
}
func (x *CreateRequest_Body) GetOwnerId() *grpc.OwnerID {
	if x != nil {
		return x.OwnerId
	}
	return nil
}
func (x *CreateRequest_Body) SetOwnerId(v *grpc.OwnerID) {
	x.OwnerId = v
}
func (x *CreateRequest_Body) GetExpiration() uint64 {
	if x != nil {
		return x.Expiration
	}
	return 0
}
func (x *CreateRequest_Body) SetExpiration(v uint64) {
	x.Expiration = v
}

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

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *CreateRequest_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *CreateRequest_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 "ownerId":
			{
				var f *grpc.OwnerID
				f = new(grpc.OwnerID)
				f.UnmarshalEasyJSON(in)
				x.OwnerId = f
			}
		case "expiration":
			{
				var f uint64
				r := in.JsonNumber()
				n := r.String()
				v, err := strconv.ParseUint(n, 10, 64)
				if err != nil {
					in.AddError(err)
					return
				}
				pv := uint64(v)
				f = pv
				x.Expiration = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type CreateRequest struct {
	Body         *CreateRequest_Body        `json:"body"`
	MetaHeader   *RequestMetaHeader         `json:"metaHeader"`
	VerifyHeader *RequestVerificationHeader `json:"verifyHeader"`
}

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

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *CreateRequest) 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 *CreateRequest) 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 *CreateRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *CreateRequest) 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 *CreateRequest) 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 *CreateRequest) 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", "CreateRequest")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(CreateRequest_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(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(RequestVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *CreateRequest) GetBody() *CreateRequest_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *CreateRequest) SetBody(v *CreateRequest_Body) {
	x.Body = v
}
func (x *CreateRequest) GetMetaHeader() *RequestMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *CreateRequest) SetMetaHeader(v *RequestMetaHeader) {
	x.MetaHeader = v
}
func (x *CreateRequest) GetVerifyHeader() *RequestVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *CreateRequest) SetVerifyHeader(v *RequestVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *CreateRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *CreateRequest) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if !first {
			out.RawByte(',')
		} else {
			first = false
		}
		const prefix string = "\"body\":"
		out.RawString(prefix)
		x.Body.MarshalEasyJSON(out)
	}
	{
		if !first {
			out.RawByte(',')
		} else {
			first = false
		}
		const prefix string = "\"metaHeader\":"
		out.RawString(prefix)
		x.MetaHeader.MarshalEasyJSON(out)
	}
	{
		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 *CreateRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *CreateRequest) 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 *CreateRequest_Body
				f = new(CreateRequest_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *RequestMetaHeader
				f = new(RequestMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *RequestVerificationHeader
				f = new(RequestVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type CreateResponse_Body struct {
	Id         []byte `json:"id"`
	SessionKey []byte `json:"sessionKey"`
}

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

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

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *CreateResponse_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 *CreateResponse_Body) EmitProtobuf(mm *easyproto.MessageMarshaler) {
	if x == nil {
		return
	}
	if len(x.Id) != 0 {
		mm.AppendBytes(1, x.Id)
	}
	if len(x.SessionKey) != 0 {
		mm.AppendBytes(2, x.SessionKey)
	}
}

// UnmarshalProtobuf implements the encoding.ProtoUnmarshaler interface.
func (x *CreateResponse_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", "CreateResponse_Body")
		}
		switch fc.FieldNum {
		case 1: // Id
			data, ok := fc.Bytes()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Id")
			}
			x.Id = data
		case 2: // SessionKey
			data, ok := fc.Bytes()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "SessionKey")
			}
			x.SessionKey = data
		}
	}
	return nil
}
func (x *CreateResponse_Body) GetId() []byte {
	if x != nil {
		return x.Id
	}
	return nil
}
func (x *CreateResponse_Body) SetId(v []byte) {
	x.Id = v
}
func (x *CreateResponse_Body) GetSessionKey() []byte {
	if x != nil {
		return x.SessionKey
	}
	return nil
}
func (x *CreateResponse_Body) SetSessionKey(v []byte) {
	x.SessionKey = v
}

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

// UnmarshalJSON implements the json.Unmarshaler interface.
func (x *CreateResponse_Body) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *CreateResponse_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 "id":
			{
				var f []byte
				{
					tmp := in.Bytes()
					if len(tmp) == 0 {
						tmp = nil
					}
					f = tmp
				}
				x.Id = f
			}
		case "sessionKey":
			{
				var f []byte
				{
					tmp := in.Bytes()
					if len(tmp) == 0 {
						tmp = nil
					}
					f = tmp
				}
				x.SessionKey = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}

type CreateResponse struct {
	Body         *CreateResponse_Body        `json:"body"`
	MetaHeader   *ResponseMetaHeader         `json:"metaHeader"`
	VerifyHeader *ResponseVerificationHeader `json:"verifyHeader"`
}

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

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *CreateResponse) 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 *CreateResponse) 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 *CreateResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().MarshalProtobuf(buf), nil
}

// MarshalProtobuf implements the encoding.ProtoMarshaler interface.
func (x *CreateResponse) 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 *CreateResponse) 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 *CreateResponse) 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", "CreateResponse")
		}
		switch fc.FieldNum {
		case 1: // Body
			data, ok := fc.MessageData()
			if !ok {
				return fmt.Errorf("cannot unmarshal field %s", "Body")
			}
			x.Body = new(CreateResponse_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(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(ResponseVerificationHeader)
			if err := x.VerifyHeader.UnmarshalProtobuf(data); err != nil {
				return fmt.Errorf("unmarshal: %w", err)
			}
		}
	}
	return nil
}
func (x *CreateResponse) GetBody() *CreateResponse_Body {
	if x != nil {
		return x.Body
	}
	return nil
}
func (x *CreateResponse) SetBody(v *CreateResponse_Body) {
	x.Body = v
}
func (x *CreateResponse) GetMetaHeader() *ResponseMetaHeader {
	if x != nil {
		return x.MetaHeader
	}
	return nil
}
func (x *CreateResponse) SetMetaHeader(v *ResponseMetaHeader) {
	x.MetaHeader = v
}
func (x *CreateResponse) GetVerifyHeader() *ResponseVerificationHeader {
	if x != nil {
		return x.VerifyHeader
	}
	return nil
}
func (x *CreateResponse) SetVerifyHeader(v *ResponseVerificationHeader) {
	x.VerifyHeader = v
}

// MarshalJSON implements the json.Marshaler interface.
func (x *CreateResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	x.MarshalEasyJSON(&w)
	return w.Buffer.BuildBytes(), w.Error
}
func (x *CreateResponse) MarshalEasyJSON(out *jwriter.Writer) {
	if x == nil {
		out.RawString("null")
		return
	}
	first := true
	out.RawByte('{')
	{
		if !first {
			out.RawByte(',')
		} else {
			first = false
		}
		const prefix string = "\"body\":"
		out.RawString(prefix)
		x.Body.MarshalEasyJSON(out)
	}
	{
		if !first {
			out.RawByte(',')
		} else {
			first = false
		}
		const prefix string = "\"metaHeader\":"
		out.RawString(prefix)
		x.MetaHeader.MarshalEasyJSON(out)
	}
	{
		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 *CreateResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	x.UnmarshalEasyJSON(&r)
	return r.Error()
}
func (x *CreateResponse) 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 *CreateResponse_Body
				f = new(CreateResponse_Body)
				f.UnmarshalEasyJSON(in)
				x.Body = f
			}
		case "metaHeader":
			{
				var f *ResponseMetaHeader
				f = new(ResponseMetaHeader)
				f.UnmarshalEasyJSON(in)
				x.MetaHeader = f
			}
		case "verifyHeader":
			{
				var f *ResponseVerificationHeader
				f = new(ResponseVerificationHeader)
				f.UnmarshalEasyJSON(in)
				x.VerifyHeader = f
			}
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}