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

package control

import "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/util/proto"

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *HealthCheckRequest_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *HealthCheckRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *HealthCheckRequest) 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 *HealthCheckRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *HealthCheckRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *HealthCheckResponse_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.EnumMarshal(1, buf[offset:], int32(x.NetmapStatus))
	offset += proto.EnumMarshal(2, buf[offset:], int32(x.HealthStatus))
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *HealthCheckResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *HealthCheckResponse) 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 *HealthCheckResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *HealthCheckResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SetNetmapStatusRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.EnumMarshal(1, buf[offset:], int32(x.Status))
	offset += proto.BoolMarshal(2, buf[offset:], x.ForceMaintenance)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SetNetmapStatusRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *SetNetmapStatusRequest) 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 *SetNetmapStatusRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *SetNetmapStatusRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SetNetmapStatusResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SetNetmapStatusResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *SetNetmapStatusResponse) 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 *SetNetmapStatusResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *SetNetmapStatusResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DropObjectsRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.AddressList)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DropObjectsRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *DropObjectsRequest) 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 *DropObjectsRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *DropObjectsRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DropObjectsResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DropObjectsResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *DropObjectsResponse) 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 *DropObjectsResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *DropObjectsResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListShardsRequest_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListShardsRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *ListShardsRequest) 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 *ListShardsRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *ListShardsRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListShardsResponse_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	for i := range x.Shards {
		offset += proto.NestedStructureMarshal(1, buf[offset:], x.Shards[i])
	}
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListShardsResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *ListShardsResponse) 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 *ListShardsResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *ListShardsResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SetShardModeRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
	offset += proto.EnumMarshal(2, buf[offset:], int32(x.Mode))
	offset += proto.BoolMarshal(3, buf[offset:], x.ResetErrorCounter)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SetShardModeRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *SetShardModeRequest) 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 *SetShardModeRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *SetShardModeRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SetShardModeResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SetShardModeResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *SetShardModeResponse) 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 *SetShardModeResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *SetShardModeResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *SynchronizeTreeRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.BytesSize(1, x.ContainerId)
	size += proto.StringSize(2, x.TreeId)
	size += proto.UInt64Size(3, x.Height)
	return size
}

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SynchronizeTreeRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.BytesMarshal(1, buf[offset:], x.ContainerId)
	offset += proto.StringMarshal(2, buf[offset:], x.TreeId)
	offset += proto.UInt64Marshal(3, buf[offset:], x.Height)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SynchronizeTreeRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *SynchronizeTreeRequest) 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 *SynchronizeTreeRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *SynchronizeTreeRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SynchronizeTreeResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SynchronizeTreeResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *SynchronizeTreeResponse) 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 *SynchronizeTreeResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *SynchronizeTreeResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *EvacuateShardRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
	offset += proto.BoolMarshal(2, buf[offset:], x.IgnoreErrors)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *EvacuateShardRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *EvacuateShardRequest) 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 *EvacuateShardRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *EvacuateShardRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *EvacuateShardResponse_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.UInt32Marshal(1, buf[offset:], x.Count)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *EvacuateShardResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *EvacuateShardResponse) 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 *EvacuateShardResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *EvacuateShardResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *FlushCacheRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
	offset += proto.BoolMarshal(2, buf[offset:], x.Seal)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *FlushCacheRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *FlushCacheRequest) 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 *FlushCacheRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *FlushCacheRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *FlushCacheResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *FlushCacheResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *FlushCacheResponse) 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 *FlushCacheResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *FlushCacheResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DoctorRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.UInt32Marshal(1, buf[offset:], x.Concurrency)
	offset += proto.BoolMarshal(2, buf[offset:], x.RemoveDuplicates)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DoctorRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *DoctorRequest) 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 *DoctorRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *DoctorRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DoctorResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DoctorResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *DoctorResponse) 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 *DoctorResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *DoctorResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *StartShardEvacuationRequest_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.RepeatedBytesSize(1, x.Shard_ID)
	size += proto.BoolSize(2, x.IgnoreErrors)
	size += proto.UInt32Size(3, x.Scope)
	return size
}

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *StartShardEvacuationRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
	offset += proto.BoolMarshal(2, buf[offset:], x.IgnoreErrors)
	offset += proto.UInt32Marshal(3, buf[offset:], x.Scope)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *StartShardEvacuationRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *StartShardEvacuationRequest) 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 *StartShardEvacuationRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *StartShardEvacuationRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *StartShardEvacuationResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *StartShardEvacuationResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *StartShardEvacuationResponse) 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 *StartShardEvacuationResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *StartShardEvacuationResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *GetShardEvacuationStatusRequest_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *GetShardEvacuationStatusRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *GetShardEvacuationStatusRequest) 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 *GetShardEvacuationStatusRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *GetShardEvacuationStatusRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *GetShardEvacuationStatusResponse_Body_UnixTimestamp) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.Int64Marshal(1, buf[offset:], x.Value)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *GetShardEvacuationStatusResponse_Body_Duration) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.Int64Marshal(1, buf[offset:], x.Seconds)
	return buf
}

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *GetShardEvacuationStatusResponse_Body) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.UInt64Size(1, x.TotalObjects)
	size += proto.UInt64Size(2, x.EvacuatedObjects)
	size += proto.UInt64Size(3, x.FailedObjects)
	size += proto.RepeatedBytesSize(4, x.Shard_ID)
	size += proto.EnumSize(5, int32(x.Status))
	size += proto.NestedStructureSize(6, x.Duration)
	size += proto.NestedStructureSize(7, x.StartedAt)
	size += proto.StringSize(8, x.ErrorMessage)
	size += proto.UInt64Size(9, x.SkippedObjects)
	size += proto.UInt64Size(10, x.TotalTrees)
	size += proto.UInt64Size(11, x.EvacuatedTrees)
	size += proto.UInt64Size(12, x.FailedTrees)
	return size
}

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *GetShardEvacuationStatusResponse_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.UInt64Marshal(1, buf[offset:], x.TotalObjects)
	offset += proto.UInt64Marshal(2, buf[offset:], x.EvacuatedObjects)
	offset += proto.UInt64Marshal(3, buf[offset:], x.FailedObjects)
	offset += proto.RepeatedBytesMarshal(4, buf[offset:], x.Shard_ID)
	offset += proto.EnumMarshal(5, buf[offset:], int32(x.Status))
	offset += proto.NestedStructureMarshal(6, buf[offset:], x.Duration)
	offset += proto.NestedStructureMarshal(7, buf[offset:], x.StartedAt)
	offset += proto.StringMarshal(8, buf[offset:], x.ErrorMessage)
	offset += proto.UInt64Marshal(9, buf[offset:], x.SkippedObjects)
	offset += proto.UInt64Marshal(10, buf[offset:], x.TotalTrees)
	offset += proto.UInt64Marshal(11, buf[offset:], x.EvacuatedTrees)
	offset += proto.UInt64Marshal(12, buf[offset:], x.FailedTrees)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *GetShardEvacuationStatusResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *GetShardEvacuationStatusResponse) 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 *GetShardEvacuationStatusResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *GetShardEvacuationStatusResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ResetShardEvacuationStatusRequest_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ResetShardEvacuationStatusRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *ResetShardEvacuationStatusRequest) 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 *ResetShardEvacuationStatusRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *ResetShardEvacuationStatusRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ResetShardEvacuationStatusResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ResetShardEvacuationStatusResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *ResetShardEvacuationStatusResponse) 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 *ResetShardEvacuationStatusResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *ResetShardEvacuationStatusResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *StopShardEvacuationRequest_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *StopShardEvacuationRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *StopShardEvacuationRequest) 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 *StopShardEvacuationRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *StopShardEvacuationRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *StopShardEvacuationResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *StopShardEvacuationResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *StopShardEvacuationResponse) 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 *StopShardEvacuationResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *StopShardEvacuationResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *AddChainLocalOverrideRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Target)
	offset += proto.BytesMarshal(2, buf[offset:], x.Chain)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *AddChainLocalOverrideRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *AddChainLocalOverrideRequest) 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 *AddChainLocalOverrideRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *AddChainLocalOverrideRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *AddChainLocalOverrideResponse_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.BytesMarshal(1, buf[offset:], x.ChainId)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *AddChainLocalOverrideResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *AddChainLocalOverrideResponse) 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 *AddChainLocalOverrideResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *AddChainLocalOverrideResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *GetChainLocalOverrideRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Target)
	offset += proto.BytesMarshal(2, buf[offset:], x.ChainId)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *GetChainLocalOverrideRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *GetChainLocalOverrideRequest) 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 *GetChainLocalOverrideRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *GetChainLocalOverrideRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *GetChainLocalOverrideResponse_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.BytesMarshal(1, buf[offset:], x.Chain)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *GetChainLocalOverrideResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *GetChainLocalOverrideResponse) 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 *GetChainLocalOverrideResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *GetChainLocalOverrideResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListChainLocalOverridesRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Target)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListChainLocalOverridesRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *ListChainLocalOverridesRequest) 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 *ListChainLocalOverridesRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *ListChainLocalOverridesRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListChainLocalOverridesResponse_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Chains)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListChainLocalOverridesResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *ListChainLocalOverridesResponse) 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 *ListChainLocalOverridesResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *ListChainLocalOverridesResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListTargetsLocalOverridesRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.StringMarshal(1, buf[offset:], x.ChainName)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListTargetsLocalOverridesRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *ListTargetsLocalOverridesRequest) 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 *ListTargetsLocalOverridesRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *ListTargetsLocalOverridesRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListTargetsLocalOverridesResponse_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	for i := range x.Targets {
		offset += proto.NestedStructureMarshal(1, buf[offset:], x.Targets[i])
	}
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *ListTargetsLocalOverridesResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *ListTargetsLocalOverridesResponse) 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 *ListTargetsLocalOverridesResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *ListTargetsLocalOverridesResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *RemoveChainLocalOverrideRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Target)
	offset += proto.BytesMarshal(2, buf[offset:], x.ChainId)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *RemoveChainLocalOverrideRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *RemoveChainLocalOverrideRequest) 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 *RemoveChainLocalOverrideRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *RemoveChainLocalOverrideRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *RemoveChainLocalOverrideResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *RemoveChainLocalOverrideResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *RemoveChainLocalOverrideResponse) 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 *RemoveChainLocalOverrideResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *RemoveChainLocalOverrideResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *RemoveChainLocalOverridesByTargetRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Target)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *RemoveChainLocalOverridesByTargetRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *RemoveChainLocalOverridesByTargetRequest) 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 *RemoveChainLocalOverridesByTargetRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *RemoveChainLocalOverridesByTargetRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *RemoveChainLocalOverridesByTargetResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *RemoveChainLocalOverridesByTargetResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *RemoveChainLocalOverridesByTargetResponse) 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 *RemoveChainLocalOverridesByTargetResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *RemoveChainLocalOverridesByTargetResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SealWriteCacheRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
	offset += proto.BoolMarshal(2, buf[offset:], x.IgnoreErrors)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SealWriteCacheRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *SealWriteCacheRequest) 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 *SealWriteCacheRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *SealWriteCacheRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

// StableSize returns the size of x in protobuf format.
//
// Structures with the same field values have the same binary size.
func (x *SealWriteCacheResponse_Body_Status) StableSize() (size int) {
	if x == nil {
		return 0
	}
	size += proto.BytesSize(1, x.Shard_ID)
	size += proto.BoolSize(2, x.Success)
	size += proto.StringSize(3, x.Error)
	return size
}

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SealWriteCacheResponse_Body_Status) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.BytesMarshal(1, buf[offset:], x.Shard_ID)
	offset += proto.BoolMarshal(2, buf[offset:], x.Success)
	offset += proto.StringMarshal(3, buf[offset:], x.Error)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SealWriteCacheResponse_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	for i := range x.Results {
		offset += proto.NestedStructureMarshal(1, buf[offset:], x.Results[i])
	}
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *SealWriteCacheResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *SealWriteCacheResponse) 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 *SealWriteCacheResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *SealWriteCacheResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DetachShardsRequest_Body) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DetachShardsRequest) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *DetachShardsRequest) 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 *DetachShardsRequest) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *DetachShardsRequest) SetSignature(sig *Signature) {
	x.Signature = sig
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DetachShardsResponse_Body) StableMarshal(buf []byte) []byte {
	return buf
}

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

// StableMarshal marshals x in protobuf binary format with stable field order.
//
// If buffer length is less than x.StableSize(), 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 binary format.
func (x *DetachShardsResponse) StableMarshal(buf []byte) []byte {
	if x == nil {
		return []byte{}
	}
	if buf == nil {
		buf = make([]byte, x.StableSize())
	}
	var offset int
	offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
	offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
	return buf
}

// 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 *DetachShardsResponse) 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 *DetachShardsResponse) ReadSignedData(buf []byte) ([]byte, error) {
	return x.GetBody().StableMarshal(buf), nil
}

func (x *DetachShardsResponse) SetSignature(sig *Signature) {
	x.Signature = sig
}