// Code generated by protoc-gen-go-lite. DO NOT EDIT.
// protoc-gen-go-lite version: v0.19.1-0.20261028131920-f644656fc4a7
// source: github.com/s4wave/spacewave/bldr/resource/resource.proto

package resource

import (
	fmt "fmt"
	io "io"
	slices "slices"
	strconv "strconv"

	protobuf_go_lite "github.com/aperturerobotics/protobuf-go-lite"
	json "github.com/aperturerobotics/protobuf-go-lite/json"
)

// ResourceFailureCode controls lifecycle recovery independently of diagnostics.
type ResourceFailureCode int32

const (
	ResourceFailureCode_RESOURCE_FAILURE_CODE_UNKNOWN                     ResourceFailureCode = 0
	ResourceFailureCode_RESOURCE_FAILURE_CODE_RESOURCE_NOT_FOUND          ResourceFailureCode = 1
	ResourceFailureCode_RESOURCE_FAILURE_CODE_CLIENT_RELEASED             ResourceFailureCode = 2
	ResourceFailureCode_RESOURCE_FAILURE_CODE_INVALID_RESOURCE_ID         ResourceFailureCode = 3
	ResourceFailureCode_RESOURCE_FAILURE_CODE_INVALID_CLIENT_ID           ResourceFailureCode = 4
	ResourceFailureCode_RESOURCE_FAILURE_CODE_RESOURCE_OR_CLIENT_RELEASED ResourceFailureCode = 5
)

// Enum value maps for ResourceFailureCode.
var (
	ResourceFailureCode_name = map[int32]string{
		0: "RESOURCE_FAILURE_CODE_UNKNOWN",
		1: "RESOURCE_FAILURE_CODE_RESOURCE_NOT_FOUND",
		2: "RESOURCE_FAILURE_CODE_CLIENT_RELEASED",
		3: "RESOURCE_FAILURE_CODE_INVALID_RESOURCE_ID",
		4: "RESOURCE_FAILURE_CODE_INVALID_CLIENT_ID",
		5: "RESOURCE_FAILURE_CODE_RESOURCE_OR_CLIENT_RELEASED",
	}
	ResourceFailureCode_value = map[string]int32{
		"RESOURCE_FAILURE_CODE_UNKNOWN":                     0,
		"RESOURCE_FAILURE_CODE_RESOURCE_NOT_FOUND":          1,
		"RESOURCE_FAILURE_CODE_CLIENT_RELEASED":             2,
		"RESOURCE_FAILURE_CODE_INVALID_RESOURCE_ID":         3,
		"RESOURCE_FAILURE_CODE_INVALID_CLIENT_ID":           4,
		"RESOURCE_FAILURE_CODE_RESOURCE_OR_CLIENT_RELEASED": 5,
	}
)

func (x ResourceFailureCode) Enum() *ResourceFailureCode {
	p := new(ResourceFailureCode)
	*p = x
	return p
}

func (x ResourceFailureCode) String() string {
	name, valid := ResourceFailureCode_name[int32(x)]
	if valid {
		return name
	}
	return strconv.Itoa(int(x))
}

// ResourceFailure carries a stable recovery code and a diagnostic message.
type ResourceFailure struct {
	unknownFields []byte
	Code          ResourceFailureCode `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	Message       string              `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}

func (x *ResourceFailure) Reset() {
	*x = ResourceFailure{}
}

func (*ResourceFailure) ProtoMessage() {}

func (x *ResourceFailure) GetCode() ResourceFailureCode {
	if x != nil {
		return x.Code
	}
	return ResourceFailureCode_RESOURCE_FAILURE_CODE_UNKNOWN
}

func (x *ResourceFailure) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

// ResourceRpcPacket negotiates a resource and carries existing SRPC data frames.
type ResourceRpcPacket struct {
	unknownFields []byte
	// Types that are assignable to Body:
	//	*ResourceRpcPacket_Init
	//	*ResourceRpcPacket_Ack
	//	*ResourceRpcPacket_Data
	//	*ResourceRpcPacket_Abandon
	Body isResourceRpcPacket_Body `protobuf_oneof:"body"`
}

func (x *ResourceRpcPacket) Reset() {
	*x = ResourceRpcPacket{}
}

func (*ResourceRpcPacket) ProtoMessage() {}

func (m *ResourceRpcPacket) GetBody() isResourceRpcPacket_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

func (x *ResourceRpcPacket) GetInit() *ResourceRpcInit {
	if x, ok := x.GetBody().(*ResourceRpcPacket_Init); ok {
		return x.Init
	}
	return nil
}

func (x *ResourceRpcPacket) GetAck() *ResourceRpcAck {
	if x, ok := x.GetBody().(*ResourceRpcPacket_Ack); ok {
		return x.Ack
	}
	return nil
}

func (x *ResourceRpcPacket) GetData() []byte {
	if x, ok := x.GetBody().(*ResourceRpcPacket_Data); ok {
		return x.Data
	}
	return nil
}

func (x *ResourceRpcPacket) GetAbandon() *ResourceRpcAbandon {
	if x, ok := x.GetBody().(*ResourceRpcPacket_Abandon); ok {
		return x.Abandon
	}
	return nil
}

type isResourceRpcPacket_Body interface {
	isResourceRpcPacket_Body()
}

type ResourceRpcPacket_Init struct {
	// Init selects the resource before any data is sent.
	Init *ResourceRpcInit `protobuf:"bytes,1,opt,name=init,proto3,oneof"`
}

type ResourceRpcPacket_Ack struct {
	// Ack reports whether the server accepted the route.
	Ack *ResourceRpcAck `protobuf:"bytes,2,opt,name=ack,proto3,oneof"`
}

type ResourceRpcPacket_Data struct {
	// Data carries an SRPC packet after the route acknowledgement.
	Data []byte `protobuf:"bytes,3,opt,name=data,proto3,oneof"`
}

type ResourceRpcPacket_Abandon struct {
	// Abandon releases this route's published children that remain unadopted.
	Abandon *ResourceRpcAbandon `protobuf:"bytes,4,opt,name=abandon,proto3,oneof"`
}

func (*ResourceRpcPacket_Init) isResourceRpcPacket_Body() {}

func (*ResourceRpcPacket_Ack) isResourceRpcPacket_Body() {}

func (*ResourceRpcPacket_Data) isResourceRpcPacket_Body() {}

func (*ResourceRpcPacket_Abandon) isResourceRpcPacket_Body() {}

// ResourceRpcInit selects a resource opened by ResourceClient or ResourceAttach.
type ResourceRpcInit struct {
	unknownFields []byte
	ResourceId    uint32 `protobuf:"varint,1,opt,name=resource_id,json=resourceId,proto3" json:"resourceId,omitempty"`
}

func (x *ResourceRpcInit) Reset() {
	*x = ResourceRpcInit{}
}

func (*ResourceRpcInit) ProtoMessage() {}

func (x *ResourceRpcInit) GetResourceId() uint32 {
	if x != nil {
		return x.ResourceId
	}
	return 0
}

// ResourceRpcAck accepts the route when failure is absent.
type ResourceRpcAck struct {
	unknownFields []byte
	Failure       *ResourceFailure `protobuf:"bytes,1,opt,name=failure,proto3" json:"failure,omitempty"`
}

func (x *ResourceRpcAck) Reset() {
	*x = ResourceRpcAck{}
}

func (*ResourceRpcAck) ProtoMessage() {}

func (x *ResourceRpcAck) GetFailure() *ResourceFailure {
	if x != nil {
		return x.Failure
	}
	return nil
}

// ResourceRpcAbandon reports that a unary caller failed to receive its result.
// The server releases only children still pending adoption, even after the
// invoked handler has returned. Closing a route alone does not abandon it.
type ResourceRpcAbandon struct {
	unknownFields []byte
}

func (x *ResourceRpcAbandon) Reset() {
	*x = ResourceRpcAbandon{}
}

func (*ResourceRpcAbandon) ProtoMessage() {}

// ResourceClientRequest is a control packet for ResourceClient.
type ResourceClientRequest struct {
	unknownFields []byte
	// ControlId orders every lifecycle control within one immutable generation.
	// Init uses zero; every later control increments the identifier by one.
	ControlId uint32 `protobuf:"varint,5,opt,name=control_id,json=controlId,proto3" json:"controlId,omitempty"`
	// Types that are assignable to Body:
	//	*ResourceClientRequest_Init
	//	*ResourceClientRequest_Adopt
	//	*ResourceClientRequest_Release
	Body isResourceClientRequest_Body `protobuf_oneof:"body"`
}

func (x *ResourceClientRequest) Reset() {
	*x = ResourceClientRequest{}
}

func (*ResourceClientRequest) ProtoMessage() {}

func (x *ResourceClientRequest) GetControlId() uint32 {
	if x != nil {
		return x.ControlId
	}
	return 0
}

func (m *ResourceClientRequest) GetBody() isResourceClientRequest_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

func (x *ResourceClientRequest) GetInit() *ResourceClientInitRequest {
	if x, ok := x.GetBody().(*ResourceClientRequest_Init); ok {
		return x.Init
	}
	return nil
}

func (x *ResourceClientRequest) GetAdopt() *ResourceClientAdopt {
	if x, ok := x.GetBody().(*ResourceClientRequest_Adopt); ok {
		return x.Adopt
	}
	return nil
}

func (x *ResourceClientRequest) GetRelease() *ResourceClientRelease {
	if x, ok := x.GetBody().(*ResourceClientRequest_Release); ok {
		return x.Release
	}
	return nil
}

type isResourceClientRequest_Body interface {
	isResourceClientRequest_Body()
}

type ResourceClientRequest_Init struct {
	// Init starts a new client generation.
	Init *ResourceClientInitRequest `protobuf:"bytes,2,opt,name=init,proto3,oneof"`
}

type ResourceClientRequest_Adopt struct {
	// Adopt detaches a pending child from its parent.
	Adopt *ResourceClientAdopt `protobuf:"bytes,3,opt,name=adopt,proto3,oneof"`
}

type ResourceClientRequest_Release struct {
	// Release releases a resource and its pending descendants.
	Release *ResourceClientRelease `protobuf:"bytes,4,opt,name=release,proto3,oneof"`
}

func (*ResourceClientRequest_Init) isResourceClientRequest_Body() {}

func (*ResourceClientRequest_Adopt) isResourceClientRequest_Body() {}

func (*ResourceClientRequest_Release) isResourceClientRequest_Body() {}

// ResourceClientInitRequest is sent first on every ResourceClient stream.
type ResourceClientInitRequest struct {
	unknownFields []byte
}

func (x *ResourceClientInitRequest) Reset() {
	*x = ResourceClientInitRequest{}
}

func (*ResourceClientInitRequest) ProtoMessage() {}

// ResourceClientAdopt adopts a pending resource.
type ResourceClientAdopt struct {
	unknownFields []byte
	// ResourceId identifies the pending resource to adopt.
	ResourceId uint32 `protobuf:"varint,1,opt,name=resource_id,json=resourceId,proto3" json:"resourceId,omitempty"`
}

func (x *ResourceClientAdopt) Reset() {
	*x = ResourceClientAdopt{}
}

func (*ResourceClientAdopt) ProtoMessage() {}

func (x *ResourceClientAdopt) GetResourceId() uint32 {
	if x != nil {
		return x.ResourceId
	}
	return 0
}

// ResourceClientRelease releases a resource and its pending descendants.
type ResourceClientRelease struct {
	unknownFields []byte
	// ResourceId identifies the resource to release.
	ResourceId uint32 `protobuf:"varint,1,opt,name=resource_id,json=resourceId,proto3" json:"resourceId,omitempty"`
}

func (x *ResourceClientRelease) Reset() {
	*x = ResourceClientRelease{}
}

func (*ResourceClientRelease) ProtoMessage() {}

func (x *ResourceClientRelease) GetResourceId() uint32 {
	if x != nil {
		return x.ResourceId
	}
	return 0
}

// ResourceClientResponse contains a server-client message for a ResourceClient request.
type ResourceClientResponse struct {
	unknownFields []byte
	// Body is the body of the event.
	//
	// Types that are assignable to Body:
	//	*ResourceClientResponse_Init
	//	*ResourceClientResponse_ResourceReleased
	//	*ResourceClientResponse_ControlAck
	Body isResourceClientResponse_Body `protobuf_oneof:"body"`
}

func (x *ResourceClientResponse) Reset() {
	*x = ResourceClientResponse{}
}

func (*ResourceClientResponse) ProtoMessage() {}

func (m *ResourceClientResponse) GetBody() isResourceClientResponse_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

func (x *ResourceClientResponse) GetInit() *ResourceClientInit {
	if x, ok := x.GetBody().(*ResourceClientResponse_Init); ok {
		return x.Init
	}
	return nil
}

func (x *ResourceClientResponse) GetResourceReleased() *ResourceReleasedResponse {
	if x, ok := x.GetBody().(*ResourceClientResponse_ResourceReleased); ok {
		return x.ResourceReleased
	}
	return nil
}

func (x *ResourceClientResponse) GetControlAck() *ResourceClientControlAck {
	if x, ok := x.GetBody().(*ResourceClientResponse_ControlAck); ok {
		return x.ControlAck
	}
	return nil
}

type isResourceClientResponse_Body interface {
	isResourceClientResponse_Body()
}

type ResourceClientResponse_Init struct {
	// Init contains the initialization message for ResourceClient.
	// This is the first message sent on the stream and is only sent once.
	Init *ResourceClientInit `protobuf:"bytes,1,opt,name=init,proto3,oneof"`
}

type ResourceClientResponse_ResourceReleased struct {
	// ResourceReleased is returned if a resource was released by the server.
	ResourceReleased *ResourceReleasedResponse `protobuf:"bytes,2,opt,name=resource_released,json=resourceReleased,proto3,oneof"`
}

type ResourceClientResponse_ControlAck struct {
	// ControlAck confirms that one lifecycle control and its callbacks completed.
	ControlAck *ResourceClientControlAck `protobuf:"bytes,4,opt,name=control_ack,json=controlAck,proto3,oneof"`
}

func (*ResourceClientResponse_Init) isResourceClientResponse_Body() {}

func (*ResourceClientResponse_ResourceReleased) isResourceClientResponse_Body() {}

func (*ResourceClientResponse_ControlAck) isResourceClientResponse_Body() {}

// ResourceClientControlAck confirms a lifecycle control completed.
type ResourceClientControlAck struct {
	unknownFields []byte
	// ControlId matches ResourceClientRequest.control_id.
	ControlId uint32 `protobuf:"varint,1,opt,name=control_id,json=controlId,proto3" json:"controlId,omitempty"`
}

func (x *ResourceClientControlAck) Reset() {
	*x = ResourceClientControlAck{}
}

func (*ResourceClientControlAck) ProtoMessage() {}

func (x *ResourceClientControlAck) GetControlId() uint32 {
	if x != nil {
		return x.ControlId
	}
	return 0
}

// ResourceReleasedResponse is a message indicating a resource was released.
type ResourceReleasedResponse struct {
	unknownFields []byte
	// ResourceId is the ID of the resource that was released.
	ResourceId uint32 `protobuf:"varint,1,opt,name=resource_id,json=resourceId,proto3" json:"resourceId,omitempty"`
}

func (x *ResourceReleasedResponse) Reset() {
	*x = ResourceReleasedResponse{}
}

func (*ResourceReleasedResponse) ProtoMessage() {}

func (x *ResourceReleasedResponse) GetResourceId() uint32 {
	if x != nil {
		return x.ResourceId
	}
	return 0
}

// ResourceClientInit is the initialization response to ResourceClient.
type ResourceClientInit struct {
	unknownFields []byte
	// ClientHandleId is the handle identifier for the client.
	ClientHandleId uint32 `protobuf:"varint,1,opt,name=client_handle_id,json=clientHandleId,proto3" json:"clientHandleId,omitempty"`
	// RootResourceId is the ID of the root resource for this client.
	RootResourceId uint32 `protobuf:"varint,2,opt,name=root_resource_id,json=rootResourceId,proto3" json:"rootResourceId,omitempty"`
}

func (x *ResourceClientInit) Reset() {
	*x = ResourceClientInit{}
}

func (*ResourceClientInit) ProtoMessage() {}

func (x *ResourceClientInit) GetClientHandleId() uint32 {
	if x != nil {
		return x.ClientHandleId
	}
	return 0
}

func (x *ResourceClientInit) GetRootResourceId() uint32 {
	if x != nil {
		return x.RootResourceId
	}
	return 0
}

// ResourceAttachRequest is a client-to-server message on the ResourceAttach stream.
type ResourceAttachRequest struct {
	unknownFields []byte
	// Body is the body of the request.
	//
	// Types that are assignable to Body:
	//	*ResourceAttachRequest_Init
	//	*ResourceAttachRequest_Add
	//	*ResourceAttachRequest_Detach
	//	*ResourceAttachRequest_MuxData
	Body isResourceAttachRequest_Body `protobuf_oneof:"body"`
}

func (x *ResourceAttachRequest) Reset() {
	*x = ResourceAttachRequest{}
}

func (*ResourceAttachRequest) ProtoMessage() {}

func (m *ResourceAttachRequest) GetBody() isResourceAttachRequest_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

func (x *ResourceAttachRequest) GetInit() *ResourceAttachInit {
	if x, ok := x.GetBody().(*ResourceAttachRequest_Init); ok {
		return x.Init
	}
	return nil
}

func (x *ResourceAttachRequest) GetAdd() *ResourceAttachAdd {
	if x, ok := x.GetBody().(*ResourceAttachRequest_Add); ok {
		return x.Add
	}
	return nil
}

func (x *ResourceAttachRequest) GetDetach() *ResourceAttachDetach {
	if x, ok := x.GetBody().(*ResourceAttachRequest_Detach); ok {
		return x.Detach
	}
	return nil
}

func (x *ResourceAttachRequest) GetMuxData() []byte {
	if x, ok := x.GetBody().(*ResourceAttachRequest_MuxData); ok {
		return x.MuxData
	}
	return nil
}

type isResourceAttachRequest_Body interface {
	isResourceAttachRequest_Body()
}

type ResourceAttachRequest_Init struct {
	// Init is the session initialization message.
	Init *ResourceAttachInit `protobuf:"bytes,1,opt,name=init,proto3,oneof"`
}

type ResourceAttachRequest_Add struct {
	// Add registers a new resource on the session.
	Add *ResourceAttachAdd `protobuf:"bytes,2,opt,name=add,proto3,oneof"`
}

type ResourceAttachRequest_Detach struct {
	// Detach withdraws a previously added resource.
	Detach *ResourceAttachDetach `protobuf:"bytes,3,opt,name=detach,proto3,oneof"`
}

type ResourceAttachRequest_MuxData struct {
	// MuxData carries yamux multiplexer frames after handshake.
	MuxData []byte `protobuf:"bytes,4,opt,name=mux_data,json=muxData,proto3,oneof"`
}

func (*ResourceAttachRequest_Init) isResourceAttachRequest_Body() {}

func (*ResourceAttachRequest_Add) isResourceAttachRequest_Body() {}

func (*ResourceAttachRequest_Detach) isResourceAttachRequest_Body() {}

func (*ResourceAttachRequest_MuxData) isResourceAttachRequest_Body() {}

// ResourceAttachResponse is a server-to-client message on the ResourceAttach stream.
type ResourceAttachResponse struct {
	unknownFields []byte
	// Body is the body of the response.
	//
	// Types that are assignable to Body:
	//	*ResourceAttachResponse_Ack
	//	*ResourceAttachResponse_AddAck
	//	*ResourceAttachResponse_DetachAck
	//	*ResourceAttachResponse_MuxData
	Body isResourceAttachResponse_Body `protobuf_oneof:"body"`
}

func (x *ResourceAttachResponse) Reset() {
	*x = ResourceAttachResponse{}
}

func (*ResourceAttachResponse) ProtoMessage() {}

func (m *ResourceAttachResponse) GetBody() isResourceAttachResponse_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

func (x *ResourceAttachResponse) GetAck() *ResourceAttachAck {
	if x, ok := x.GetBody().(*ResourceAttachResponse_Ack); ok {
		return x.Ack
	}
	return nil
}

func (x *ResourceAttachResponse) GetAddAck() *ResourceAttachAddAck {
	if x, ok := x.GetBody().(*ResourceAttachResponse_AddAck); ok {
		return x.AddAck
	}
	return nil
}

func (x *ResourceAttachResponse) GetDetachAck() *ResourceAttachDetachAck {
	if x, ok := x.GetBody().(*ResourceAttachResponse_DetachAck); ok {
		return x.DetachAck
	}
	return nil
}

func (x *ResourceAttachResponse) GetMuxData() []byte {
	if x, ok := x.GetBody().(*ResourceAttachResponse_MuxData); ok {
		return x.MuxData
	}
	return nil
}

type isResourceAttachResponse_Body interface {
	isResourceAttachResponse_Body()
}

type ResourceAttachResponse_Ack struct {
	// Ack is the session acknowledgment.
	Ack *ResourceAttachAck `protobuf:"bytes,1,opt,name=ack,proto3,oneof"`
}

type ResourceAttachResponse_AddAck struct {
	// AddAck confirms a resource was added.
	AddAck *ResourceAttachAddAck `protobuf:"bytes,2,opt,name=add_ack,json=addAck,proto3,oneof"`
}

type ResourceAttachResponse_DetachAck struct {
	// DetachAck confirms a resource was detached.
	DetachAck *ResourceAttachDetachAck `protobuf:"bytes,3,opt,name=detach_ack,json=detachAck,proto3,oneof"`
}

type ResourceAttachResponse_MuxData struct {
	// MuxData carries yamux multiplexer frames after handshake.
	MuxData []byte `protobuf:"bytes,4,opt,name=mux_data,json=muxData,proto3,oneof"`
}

func (*ResourceAttachResponse_Ack) isResourceAttachResponse_Body() {}

func (*ResourceAttachResponse_AddAck) isResourceAttachResponse_Body() {}

func (*ResourceAttachResponse_DetachAck) isResourceAttachResponse_Body() {}

func (*ResourceAttachResponse_MuxData) isResourceAttachResponse_Body() {}

// ResourceAttachInit is sent by the client to initiate a session.
type ResourceAttachInit struct {
	unknownFields []byte
	// ClientHandleId identifies the owning client session.
	ClientHandleId uint32 `protobuf:"varint,1,opt,name=client_handle_id,json=clientHandleId,proto3" json:"clientHandleId,omitempty"`
}

func (x *ResourceAttachInit) Reset() {
	*x = ResourceAttachInit{}
}

func (*ResourceAttachInit) ProtoMessage() {}

func (x *ResourceAttachInit) GetClientHandleId() uint32 {
	if x != nil {
		return x.ClientHandleId
	}
	return 0
}

// ResourceAttachAck is sent by the server to confirm the session.
type ResourceAttachAck struct {
	unknownFields []byte
	// Failure is set if the session was rejected.
	Failure *ResourceFailure `protobuf:"bytes,1,opt,name=failure,proto3" json:"failure,omitempty"`
}

func (x *ResourceAttachAck) Reset() {
	*x = ResourceAttachAck{}
}

func (*ResourceAttachAck) ProtoMessage() {}

func (x *ResourceAttachAck) GetFailure() *ResourceFailure {
	if x != nil {
		return x.Failure
	}
	return nil
}

// ResourceAttachAdd is sent by the client to register a resource.
type ResourceAttachAdd struct {
	unknownFields []byte
	// AttachId is a client-chosen correlation ID.
	AttachId uint32 `protobuf:"varint,1,opt,name=attach_id,json=attachId,proto3" json:"attachId,omitempty"`
	// Label is an informational description of the attached resource.
	Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"`
}

func (x *ResourceAttachAdd) Reset() {
	*x = ResourceAttachAdd{}
}

func (*ResourceAttachAdd) ProtoMessage() {}

func (x *ResourceAttachAdd) GetAttachId() uint32 {
	if x != nil {
		return x.AttachId
	}
	return 0
}

func (x *ResourceAttachAdd) GetLabel() string {
	if x != nil {
		return x.Label
	}
	return ""
}

// ResourceAttachAddAck is sent by the server to confirm a resource was added.
type ResourceAttachAddAck struct {
	unknownFields []byte
	// AttachId echoes the client-chosen correlation ID.
	AttachId uint32 `protobuf:"varint,1,opt,name=attach_id,json=attachId,proto3" json:"attachId,omitempty"`
	// Failure is set if the add was rejected.
	Failure *ResourceFailure `protobuf:"bytes,2,opt,name=failure,proto3" json:"failure,omitempty"`
	// ResourceId is the server-assigned ID for the attached resource.
	ResourceId uint32 `protobuf:"varint,3,opt,name=resource_id,json=resourceId,proto3" json:"resourceId,omitempty"`
}

func (x *ResourceAttachAddAck) Reset() {
	*x = ResourceAttachAddAck{}
}

func (*ResourceAttachAddAck) ProtoMessage() {}

func (x *ResourceAttachAddAck) GetAttachId() uint32 {
	if x != nil {
		return x.AttachId
	}
	return 0
}

func (x *ResourceAttachAddAck) GetFailure() *ResourceFailure {
	if x != nil {
		return x.Failure
	}
	return nil
}

func (x *ResourceAttachAddAck) GetResourceId() uint32 {
	if x != nil {
		return x.ResourceId
	}
	return 0
}

// ResourceAttachDetach is sent by the client to withdraw a resource.
type ResourceAttachDetach struct {
	unknownFields []byte
	// ResourceId is the server-assigned ID to detach.
	ResourceId uint32 `protobuf:"varint,1,opt,name=resource_id,json=resourceId,proto3" json:"resourceId,omitempty"`
}

func (x *ResourceAttachDetach) Reset() {
	*x = ResourceAttachDetach{}
}

func (*ResourceAttachDetach) ProtoMessage() {}

func (x *ResourceAttachDetach) GetResourceId() uint32 {
	if x != nil {
		return x.ResourceId
	}
	return 0
}

// ResourceAttachDetachAck is sent by the server to confirm a resource was detached.
type ResourceAttachDetachAck struct {
	unknownFields []byte
	// ResourceId confirms which resource was detached.
	ResourceId uint32 `protobuf:"varint,1,opt,name=resource_id,json=resourceId,proto3" json:"resourceId,omitempty"`
}

func (x *ResourceAttachDetachAck) Reset() {
	*x = ResourceAttachDetachAck{}
}

func (*ResourceAttachDetachAck) ProtoMessage() {}

func (x *ResourceAttachDetachAck) GetResourceId() uint32 {
	if x != nil {
		return x.ResourceId
	}
	return 0
}

func (m *ResourceFailure) CloneVT() *ResourceFailure {
	if m == nil {
		return (*ResourceFailure)(nil)
	}
	r := new(ResourceFailure)
	r.Code = m.Code
	r.Message = m.Message
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceFailure) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceRpcPacket) CloneVT() *ResourceRpcPacket {
	if m == nil {
		return (*ResourceRpcPacket)(nil)
	}
	r := new(ResourceRpcPacket)
	if m.Body != nil {
		r.Body = m.Body.(interface {
			CloneOneofVT() isResourceRpcPacket_Body
		}).CloneOneofVT()
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceRpcPacket) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceRpcPacket_Init) CloneVT() *ResourceRpcPacket_Init {
	if m == nil {
		return (*ResourceRpcPacket_Init)(nil)
	}
	r := new(ResourceRpcPacket_Init)
	r.Init = protobuf_go_lite.CloneVTValue(m.Init)
	return r
}

func (m *ResourceRpcPacket_Init) CloneOneofVT() isResourceRpcPacket_Body {
	return m.CloneVT()
}

func (m *ResourceRpcPacket_Ack) CloneVT() *ResourceRpcPacket_Ack {
	if m == nil {
		return (*ResourceRpcPacket_Ack)(nil)
	}
	r := new(ResourceRpcPacket_Ack)
	r.Ack = protobuf_go_lite.CloneVTValue(m.Ack)
	return r
}

func (m *ResourceRpcPacket_Ack) CloneOneofVT() isResourceRpcPacket_Body {
	return m.CloneVT()
}

func (m *ResourceRpcPacket_Data) CloneVT() *ResourceRpcPacket_Data {
	if m == nil {
		return (*ResourceRpcPacket_Data)(nil)
	}
	r := new(ResourceRpcPacket_Data)
	r.Data = protobuf_go_lite.CloneBytes(m.Data)
	return r
}

func (m *ResourceRpcPacket_Data) CloneOneofVT() isResourceRpcPacket_Body {
	return m.CloneVT()
}

func (m *ResourceRpcPacket_Abandon) CloneVT() *ResourceRpcPacket_Abandon {
	if m == nil {
		return (*ResourceRpcPacket_Abandon)(nil)
	}
	r := new(ResourceRpcPacket_Abandon)
	r.Abandon = protobuf_go_lite.CloneVTValue(m.Abandon)
	return r
}

func (m *ResourceRpcPacket_Abandon) CloneOneofVT() isResourceRpcPacket_Body {
	return m.CloneVT()
}

func (m *ResourceRpcInit) CloneVT() *ResourceRpcInit {
	if m == nil {
		return (*ResourceRpcInit)(nil)
	}
	r := new(ResourceRpcInit)
	r.ResourceId = m.ResourceId
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceRpcInit) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceRpcAck) CloneVT() *ResourceRpcAck {
	if m == nil {
		return (*ResourceRpcAck)(nil)
	}
	r := new(ResourceRpcAck)
	r.Failure = protobuf_go_lite.CloneVTValue(m.Failure)
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceRpcAck) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceRpcAbandon) CloneVT() *ResourceRpcAbandon {
	if m == nil {
		return (*ResourceRpcAbandon)(nil)
	}
	r := new(ResourceRpcAbandon)
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceRpcAbandon) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceClientRequest) CloneVT() *ResourceClientRequest {
	if m == nil {
		return (*ResourceClientRequest)(nil)
	}
	r := new(ResourceClientRequest)
	r.ControlId = m.ControlId
	if m.Body != nil {
		r.Body = m.Body.(interface {
			CloneOneofVT() isResourceClientRequest_Body
		}).CloneOneofVT()
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceClientRequest) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceClientRequest_Init) CloneVT() *ResourceClientRequest_Init {
	if m == nil {
		return (*ResourceClientRequest_Init)(nil)
	}
	r := new(ResourceClientRequest_Init)
	r.Init = protobuf_go_lite.CloneVTValue(m.Init)
	return r
}

func (m *ResourceClientRequest_Init) CloneOneofVT() isResourceClientRequest_Body {
	return m.CloneVT()
}

func (m *ResourceClientRequest_Adopt) CloneVT() *ResourceClientRequest_Adopt {
	if m == nil {
		return (*ResourceClientRequest_Adopt)(nil)
	}
	r := new(ResourceClientRequest_Adopt)
	r.Adopt = protobuf_go_lite.CloneVTValue(m.Adopt)
	return r
}

func (m *ResourceClientRequest_Adopt) CloneOneofVT() isResourceClientRequest_Body {
	return m.CloneVT()
}

func (m *ResourceClientRequest_Release) CloneVT() *ResourceClientRequest_Release {
	if m == nil {
		return (*ResourceClientRequest_Release)(nil)
	}
	r := new(ResourceClientRequest_Release)
	r.Release = protobuf_go_lite.CloneVTValue(m.Release)
	return r
}

func (m *ResourceClientRequest_Release) CloneOneofVT() isResourceClientRequest_Body {
	return m.CloneVT()
}

func (m *ResourceClientInitRequest) CloneVT() *ResourceClientInitRequest {
	if m == nil {
		return (*ResourceClientInitRequest)(nil)
	}
	r := new(ResourceClientInitRequest)
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceClientInitRequest) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceClientAdopt) CloneVT() *ResourceClientAdopt {
	if m == nil {
		return (*ResourceClientAdopt)(nil)
	}
	r := new(ResourceClientAdopt)
	r.ResourceId = m.ResourceId
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceClientAdopt) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceClientRelease) CloneVT() *ResourceClientRelease {
	if m == nil {
		return (*ResourceClientRelease)(nil)
	}
	r := new(ResourceClientRelease)
	r.ResourceId = m.ResourceId
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceClientRelease) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceClientResponse) CloneVT() *ResourceClientResponse {
	if m == nil {
		return (*ResourceClientResponse)(nil)
	}
	r := new(ResourceClientResponse)
	if m.Body != nil {
		r.Body = m.Body.(interface {
			CloneOneofVT() isResourceClientResponse_Body
		}).CloneOneofVT()
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceClientResponse) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceClientResponse_Init) CloneVT() *ResourceClientResponse_Init {
	if m == nil {
		return (*ResourceClientResponse_Init)(nil)
	}
	r := new(ResourceClientResponse_Init)
	r.Init = protobuf_go_lite.CloneVTValue(m.Init)
	return r
}

func (m *ResourceClientResponse_Init) CloneOneofVT() isResourceClientResponse_Body {
	return m.CloneVT()
}

func (m *ResourceClientResponse_ResourceReleased) CloneVT() *ResourceClientResponse_ResourceReleased {
	if m == nil {
		return (*ResourceClientResponse_ResourceReleased)(nil)
	}
	r := new(ResourceClientResponse_ResourceReleased)
	r.ResourceReleased = protobuf_go_lite.CloneVTValue(m.ResourceReleased)
	return r
}

func (m *ResourceClientResponse_ResourceReleased) CloneOneofVT() isResourceClientResponse_Body {
	return m.CloneVT()
}

func (m *ResourceClientResponse_ControlAck) CloneVT() *ResourceClientResponse_ControlAck {
	if m == nil {
		return (*ResourceClientResponse_ControlAck)(nil)
	}
	r := new(ResourceClientResponse_ControlAck)
	r.ControlAck = protobuf_go_lite.CloneVTValue(m.ControlAck)
	return r
}

func (m *ResourceClientResponse_ControlAck) CloneOneofVT() isResourceClientResponse_Body {
	return m.CloneVT()
}

func (m *ResourceClientControlAck) CloneVT() *ResourceClientControlAck {
	if m == nil {
		return (*ResourceClientControlAck)(nil)
	}
	r := new(ResourceClientControlAck)
	r.ControlId = m.ControlId
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceClientControlAck) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceReleasedResponse) CloneVT() *ResourceReleasedResponse {
	if m == nil {
		return (*ResourceReleasedResponse)(nil)
	}
	r := new(ResourceReleasedResponse)
	r.ResourceId = m.ResourceId
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceReleasedResponse) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceClientInit) CloneVT() *ResourceClientInit {
	if m == nil {
		return (*ResourceClientInit)(nil)
	}
	r := new(ResourceClientInit)
	r.ClientHandleId = m.ClientHandleId
	r.RootResourceId = m.RootResourceId
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceClientInit) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceAttachRequest) CloneVT() *ResourceAttachRequest {
	if m == nil {
		return (*ResourceAttachRequest)(nil)
	}
	r := new(ResourceAttachRequest)
	if m.Body != nil {
		r.Body = m.Body.(interface {
			CloneOneofVT() isResourceAttachRequest_Body
		}).CloneOneofVT()
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceAttachRequest) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceAttachRequest_Init) CloneVT() *ResourceAttachRequest_Init {
	if m == nil {
		return (*ResourceAttachRequest_Init)(nil)
	}
	r := new(ResourceAttachRequest_Init)
	r.Init = protobuf_go_lite.CloneVTValue(m.Init)
	return r
}

func (m *ResourceAttachRequest_Init) CloneOneofVT() isResourceAttachRequest_Body {
	return m.CloneVT()
}

func (m *ResourceAttachRequest_Add) CloneVT() *ResourceAttachRequest_Add {
	if m == nil {
		return (*ResourceAttachRequest_Add)(nil)
	}
	r := new(ResourceAttachRequest_Add)
	r.Add = protobuf_go_lite.CloneVTValue(m.Add)
	return r
}

func (m *ResourceAttachRequest_Add) CloneOneofVT() isResourceAttachRequest_Body {
	return m.CloneVT()
}

func (m *ResourceAttachRequest_Detach) CloneVT() *ResourceAttachRequest_Detach {
	if m == nil {
		return (*ResourceAttachRequest_Detach)(nil)
	}
	r := new(ResourceAttachRequest_Detach)
	r.Detach = protobuf_go_lite.CloneVTValue(m.Detach)
	return r
}

func (m *ResourceAttachRequest_Detach) CloneOneofVT() isResourceAttachRequest_Body {
	return m.CloneVT()
}

func (m *ResourceAttachRequest_MuxData) CloneVT() *ResourceAttachRequest_MuxData {
	if m == nil {
		return (*ResourceAttachRequest_MuxData)(nil)
	}
	r := new(ResourceAttachRequest_MuxData)
	r.MuxData = protobuf_go_lite.CloneBytes(m.MuxData)
	return r
}

func (m *ResourceAttachRequest_MuxData) CloneOneofVT() isResourceAttachRequest_Body {
	return m.CloneVT()
}

func (m *ResourceAttachResponse) CloneVT() *ResourceAttachResponse {
	if m == nil {
		return (*ResourceAttachResponse)(nil)
	}
	r := new(ResourceAttachResponse)
	if m.Body != nil {
		r.Body = m.Body.(interface {
			CloneOneofVT() isResourceAttachResponse_Body
		}).CloneOneofVT()
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceAttachResponse) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceAttachResponse_Ack) CloneVT() *ResourceAttachResponse_Ack {
	if m == nil {
		return (*ResourceAttachResponse_Ack)(nil)
	}
	r := new(ResourceAttachResponse_Ack)
	r.Ack = protobuf_go_lite.CloneVTValue(m.Ack)
	return r
}

func (m *ResourceAttachResponse_Ack) CloneOneofVT() isResourceAttachResponse_Body {
	return m.CloneVT()
}

func (m *ResourceAttachResponse_AddAck) CloneVT() *ResourceAttachResponse_AddAck {
	if m == nil {
		return (*ResourceAttachResponse_AddAck)(nil)
	}
	r := new(ResourceAttachResponse_AddAck)
	r.AddAck = protobuf_go_lite.CloneVTValue(m.AddAck)
	return r
}

func (m *ResourceAttachResponse_AddAck) CloneOneofVT() isResourceAttachResponse_Body {
	return m.CloneVT()
}

func (m *ResourceAttachResponse_DetachAck) CloneVT() *ResourceAttachResponse_DetachAck {
	if m == nil {
		return (*ResourceAttachResponse_DetachAck)(nil)
	}
	r := new(ResourceAttachResponse_DetachAck)
	r.DetachAck = protobuf_go_lite.CloneVTValue(m.DetachAck)
	return r
}

func (m *ResourceAttachResponse_DetachAck) CloneOneofVT() isResourceAttachResponse_Body {
	return m.CloneVT()
}

func (m *ResourceAttachResponse_MuxData) CloneVT() *ResourceAttachResponse_MuxData {
	if m == nil {
		return (*ResourceAttachResponse_MuxData)(nil)
	}
	r := new(ResourceAttachResponse_MuxData)
	r.MuxData = protobuf_go_lite.CloneBytes(m.MuxData)
	return r
}

func (m *ResourceAttachResponse_MuxData) CloneOneofVT() isResourceAttachResponse_Body {
	return m.CloneVT()
}

func (m *ResourceAttachInit) CloneVT() *ResourceAttachInit {
	if m == nil {
		return (*ResourceAttachInit)(nil)
	}
	r := new(ResourceAttachInit)
	r.ClientHandleId = m.ClientHandleId
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceAttachInit) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceAttachAck) CloneVT() *ResourceAttachAck {
	if m == nil {
		return (*ResourceAttachAck)(nil)
	}
	r := new(ResourceAttachAck)
	r.Failure = protobuf_go_lite.CloneVTValue(m.Failure)
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceAttachAck) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceAttachAdd) CloneVT() *ResourceAttachAdd {
	if m == nil {
		return (*ResourceAttachAdd)(nil)
	}
	r := new(ResourceAttachAdd)
	r.AttachId = m.AttachId
	r.Label = m.Label
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceAttachAdd) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceAttachAddAck) CloneVT() *ResourceAttachAddAck {
	if m == nil {
		return (*ResourceAttachAddAck)(nil)
	}
	r := new(ResourceAttachAddAck)
	r.AttachId = m.AttachId
	r.ResourceId = m.ResourceId
	r.Failure = protobuf_go_lite.CloneVTValue(m.Failure)
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceAttachAddAck) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceAttachDetach) CloneVT() *ResourceAttachDetach {
	if m == nil {
		return (*ResourceAttachDetach)(nil)
	}
	r := new(ResourceAttachDetach)
	r.ResourceId = m.ResourceId
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceAttachDetach) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ResourceAttachDetachAck) CloneVT() *ResourceAttachDetachAck {
	if m == nil {
		return (*ResourceAttachDetachAck)(nil)
	}
	r := new(ResourceAttachDetachAck)
	r.ResourceId = m.ResourceId
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *ResourceAttachDetachAck) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (this *ResourceFailure) EqualVT(that *ResourceFailure) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Code != that.Code {
		return false
	}
	if this.Message != that.Message {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceFailure) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceFailure)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceRpcPacket) EqualVT(that *ResourceRpcPacket) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Body == nil && that.Body != nil {
		return false
	} else if this.Body != nil {
		if that.Body == nil {
			return false
		}
		if !this.Body.(interface {
			EqualVT(isResourceRpcPacket_Body) bool
		}).EqualVT(that.Body) {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceRpcPacket) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceRpcPacket)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceRpcPacket_Init) EqualVT(thatIface isResourceRpcPacket_Body) bool {
	that, ok := thatIface.(*ResourceRpcPacket_Init)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Init, that.Init, func() *ResourceRpcInit { return &ResourceRpcInit{} }) {
		return false
	}
	return true
}

func (this *ResourceRpcPacket_Ack) EqualVT(thatIface isResourceRpcPacket_Body) bool {
	that, ok := thatIface.(*ResourceRpcPacket_Ack)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Ack, that.Ack, func() *ResourceRpcAck { return &ResourceRpcAck{} }) {
		return false
	}
	return true
}

func (this *ResourceRpcPacket_Data) EqualVT(thatIface isResourceRpcPacket_Body) bool {
	that, ok := thatIface.(*ResourceRpcPacket_Data)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualBytes(this.Data, that.Data) {
		return false
	}
	return true
}

func (this *ResourceRpcPacket_Abandon) EqualVT(thatIface isResourceRpcPacket_Body) bool {
	that, ok := thatIface.(*ResourceRpcPacket_Abandon)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Abandon, that.Abandon, func() *ResourceRpcAbandon { return &ResourceRpcAbandon{} }) {
		return false
	}
	return true
}

func (this *ResourceRpcInit) EqualVT(that *ResourceRpcInit) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ResourceId != that.ResourceId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceRpcInit) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceRpcInit)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceRpcAck) EqualVT(that *ResourceRpcAck) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if !protobuf_go_lite.IsEqualVT(this.Failure, that.Failure) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceRpcAck) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceRpcAck)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceRpcAbandon) EqualVT(that *ResourceRpcAbandon) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceRpcAbandon) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceRpcAbandon)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceClientRequest) EqualVT(that *ResourceClientRequest) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Body == nil && that.Body != nil {
		return false
	} else if this.Body != nil {
		if that.Body == nil {
			return false
		}
		if !this.Body.(interface {
			EqualVT(isResourceClientRequest_Body) bool
		}).EqualVT(that.Body) {
			return false
		}
	}
	if this.ControlId != that.ControlId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceClientRequest) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceClientRequest)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceClientRequest_Init) EqualVT(thatIface isResourceClientRequest_Body) bool {
	that, ok := thatIface.(*ResourceClientRequest_Init)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Init, that.Init, func() *ResourceClientInitRequest { return &ResourceClientInitRequest{} }) {
		return false
	}
	return true
}

func (this *ResourceClientRequest_Adopt) EqualVT(thatIface isResourceClientRequest_Body) bool {
	that, ok := thatIface.(*ResourceClientRequest_Adopt)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Adopt, that.Adopt, func() *ResourceClientAdopt { return &ResourceClientAdopt{} }) {
		return false
	}
	return true
}

func (this *ResourceClientRequest_Release) EqualVT(thatIface isResourceClientRequest_Body) bool {
	that, ok := thatIface.(*ResourceClientRequest_Release)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Release, that.Release, func() *ResourceClientRelease { return &ResourceClientRelease{} }) {
		return false
	}
	return true
}

func (this *ResourceClientInitRequest) EqualVT(that *ResourceClientInitRequest) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceClientInitRequest) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceClientInitRequest)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceClientAdopt) EqualVT(that *ResourceClientAdopt) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ResourceId != that.ResourceId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceClientAdopt) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceClientAdopt)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceClientRelease) EqualVT(that *ResourceClientRelease) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ResourceId != that.ResourceId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceClientRelease) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceClientRelease)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceClientResponse) EqualVT(that *ResourceClientResponse) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Body == nil && that.Body != nil {
		return false
	} else if this.Body != nil {
		if that.Body == nil {
			return false
		}
		if !this.Body.(interface {
			EqualVT(isResourceClientResponse_Body) bool
		}).EqualVT(that.Body) {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceClientResponse) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceClientResponse)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceClientResponse_Init) EqualVT(thatIface isResourceClientResponse_Body) bool {
	that, ok := thatIface.(*ResourceClientResponse_Init)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Init, that.Init, func() *ResourceClientInit { return &ResourceClientInit{} }) {
		return false
	}
	return true
}

func (this *ResourceClientResponse_ResourceReleased) EqualVT(thatIface isResourceClientResponse_Body) bool {
	that, ok := thatIface.(*ResourceClientResponse_ResourceReleased)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.ResourceReleased, that.ResourceReleased, func() *ResourceReleasedResponse { return &ResourceReleasedResponse{} }) {
		return false
	}
	return true
}

func (this *ResourceClientResponse_ControlAck) EqualVT(thatIface isResourceClientResponse_Body) bool {
	that, ok := thatIface.(*ResourceClientResponse_ControlAck)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.ControlAck, that.ControlAck, func() *ResourceClientControlAck { return &ResourceClientControlAck{} }) {
		return false
	}
	return true
}

func (this *ResourceClientControlAck) EqualVT(that *ResourceClientControlAck) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ControlId != that.ControlId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceClientControlAck) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceClientControlAck)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceReleasedResponse) EqualVT(that *ResourceReleasedResponse) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ResourceId != that.ResourceId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceReleasedResponse) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceReleasedResponse)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceClientInit) EqualVT(that *ResourceClientInit) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ClientHandleId != that.ClientHandleId {
		return false
	}
	if this.RootResourceId != that.RootResourceId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceClientInit) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceClientInit)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceAttachRequest) EqualVT(that *ResourceAttachRequest) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Body == nil && that.Body != nil {
		return false
	} else if this.Body != nil {
		if that.Body == nil {
			return false
		}
		if !this.Body.(interface {
			EqualVT(isResourceAttachRequest_Body) bool
		}).EqualVT(that.Body) {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceAttachRequest) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceAttachRequest)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceAttachRequest_Init) EqualVT(thatIface isResourceAttachRequest_Body) bool {
	that, ok := thatIface.(*ResourceAttachRequest_Init)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Init, that.Init, func() *ResourceAttachInit { return &ResourceAttachInit{} }) {
		return false
	}
	return true
}

func (this *ResourceAttachRequest_Add) EqualVT(thatIface isResourceAttachRequest_Body) bool {
	that, ok := thatIface.(*ResourceAttachRequest_Add)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Add, that.Add, func() *ResourceAttachAdd { return &ResourceAttachAdd{} }) {
		return false
	}
	return true
}

func (this *ResourceAttachRequest_Detach) EqualVT(thatIface isResourceAttachRequest_Body) bool {
	that, ok := thatIface.(*ResourceAttachRequest_Detach)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Detach, that.Detach, func() *ResourceAttachDetach { return &ResourceAttachDetach{} }) {
		return false
	}
	return true
}

func (this *ResourceAttachRequest_MuxData) EqualVT(thatIface isResourceAttachRequest_Body) bool {
	that, ok := thatIface.(*ResourceAttachRequest_MuxData)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualBytes(this.MuxData, that.MuxData) {
		return false
	}
	return true
}

func (this *ResourceAttachResponse) EqualVT(that *ResourceAttachResponse) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Body == nil && that.Body != nil {
		return false
	} else if this.Body != nil {
		if that.Body == nil {
			return false
		}
		if !this.Body.(interface {
			EqualVT(isResourceAttachResponse_Body) bool
		}).EqualVT(that.Body) {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceAttachResponse) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceAttachResponse)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceAttachResponse_Ack) EqualVT(thatIface isResourceAttachResponse_Body) bool {
	that, ok := thatIface.(*ResourceAttachResponse_Ack)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.Ack, that.Ack, func() *ResourceAttachAck { return &ResourceAttachAck{} }) {
		return false
	}
	return true
}

func (this *ResourceAttachResponse_AddAck) EqualVT(thatIface isResourceAttachResponse_Body) bool {
	that, ok := thatIface.(*ResourceAttachResponse_AddAck)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.AddAck, that.AddAck, func() *ResourceAttachAddAck { return &ResourceAttachAddAck{} }) {
		return false
	}
	return true
}

func (this *ResourceAttachResponse_DetachAck) EqualVT(thatIface isResourceAttachResponse_Body) bool {
	that, ok := thatIface.(*ResourceAttachResponse_DetachAck)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualVTImplicit(this.DetachAck, that.DetachAck, func() *ResourceAttachDetachAck { return &ResourceAttachDetachAck{} }) {
		return false
	}
	return true
}

func (this *ResourceAttachResponse_MuxData) EqualVT(thatIface isResourceAttachResponse_Body) bool {
	that, ok := thatIface.(*ResourceAttachResponse_MuxData)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if !protobuf_go_lite.EqualBytes(this.MuxData, that.MuxData) {
		return false
	}
	return true
}

func (this *ResourceAttachInit) EqualVT(that *ResourceAttachInit) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ClientHandleId != that.ClientHandleId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceAttachInit) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceAttachInit)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceAttachAck) EqualVT(that *ResourceAttachAck) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if !protobuf_go_lite.IsEqualVT(this.Failure, that.Failure) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceAttachAck) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceAttachAck)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceAttachAdd) EqualVT(that *ResourceAttachAdd) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.AttachId != that.AttachId {
		return false
	}
	if this.Label != that.Label {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceAttachAdd) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceAttachAdd)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceAttachAddAck) EqualVT(that *ResourceAttachAddAck) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.AttachId != that.AttachId {
		return false
	}
	if !protobuf_go_lite.IsEqualVT(this.Failure, that.Failure) {
		return false
	}
	if this.ResourceId != that.ResourceId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceAttachAddAck) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceAttachAddAck)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceAttachDetach) EqualVT(that *ResourceAttachDetach) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ResourceId != that.ResourceId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceAttachDetach) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceAttachDetach)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

func (this *ResourceAttachDetachAck) EqualVT(that *ResourceAttachDetachAck) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ResourceId != that.ResourceId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ResourceAttachDetachAck) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ResourceAttachDetachAck)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

// MarshalProtoJSON marshals the ResourceFailureCode to JSON.
func (x ResourceFailureCode) MarshalProtoJSON(s *json.MarshalState) {
	s.WriteEnum(int32(x), ResourceFailureCode_name)
}

// MarshalText marshals the ResourceFailureCode to text.
func (x ResourceFailureCode) MarshalText() ([]byte, error) {
	return []byte(json.GetEnumString(int32(x), ResourceFailureCode_name)), nil
}

// MarshalJSON marshals the ResourceFailureCode to JSON.
func (x ResourceFailureCode) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceFailureCode from JSON.
func (x *ResourceFailureCode) UnmarshalProtoJSON(s *json.UnmarshalState) {
	v := s.ReadEnum(ResourceFailureCode_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read ResourceFailureCode enum: %v", err)
		return
	}
	*x = ResourceFailureCode(v)
}

// UnmarshalText unmarshals the ResourceFailureCode from text.
func (x *ResourceFailureCode) UnmarshalText(b []byte) error {
	i, err := json.ParseEnumString(string(b), ResourceFailureCode_value)
	if err != nil {
		return err
	}
	*x = ResourceFailureCode(i)
	return nil
}

// UnmarshalJSON unmarshals the ResourceFailureCode from JSON.
func (x *ResourceFailureCode) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceFailure message to JSON.
func (x *ResourceFailure) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Code != 0 || s.HasField("code") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("code")
		x.Code.MarshalProtoJSON(s)
	}
	if x.Message != "" || s.HasField("message") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("message")
		s.WriteString(x.Message)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceFailure to JSON.
func (x *ResourceFailure) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceFailure message from JSON.
func (x *ResourceFailure) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "code":
			s.AddField("code")
			x.Code.UnmarshalProtoJSON(s)
		case "message":
			s.AddField("message")
			x.Message = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceFailure from JSON.
func (x *ResourceFailure) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceRpcPacket message to JSON.
func (x *ResourceRpcPacket) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Body != nil {
		switch ov := x.Body.(type) {
		case *ResourceRpcPacket_Init:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("init")
			ov.Init.MarshalProtoJSON(s.WithField("init"))
		case *ResourceRpcPacket_Ack:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("ack")
			ov.Ack.MarshalProtoJSON(s.WithField("ack"))
		case *ResourceRpcPacket_Data:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("data")
			s.WriteBytes(ov.Data)
		case *ResourceRpcPacket_Abandon:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("abandon")
			ov.Abandon.MarshalProtoJSON(s.WithField("abandon"))
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceRpcPacket to JSON.
func (x *ResourceRpcPacket) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceRpcPacket message from JSON.
func (x *ResourceRpcPacket) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "init":
			ov := &ResourceRpcPacket_Init{}
			x.Body = ov
			if s.ReadNil() {
				ov.Init = nil
				return
			}
			ov.Init = &ResourceRpcInit{}
			ov.Init.UnmarshalProtoJSON(s.WithField("init", true))
		case "ack":
			ov := &ResourceRpcPacket_Ack{}
			x.Body = ov
			if s.ReadNil() {
				ov.Ack = nil
				return
			}
			ov.Ack = &ResourceRpcAck{}
			ov.Ack.UnmarshalProtoJSON(s.WithField("ack", true))
		case "data":
			s.AddField("data")
			ov := &ResourceRpcPacket_Data{}
			x.Body = ov
			ov.Data = s.ReadBytes()
		case "abandon":
			ov := &ResourceRpcPacket_Abandon{}
			x.Body = ov
			if s.ReadNil() {
				ov.Abandon = nil
				return
			}
			ov.Abandon = &ResourceRpcAbandon{}
			ov.Abandon.UnmarshalProtoJSON(s.WithField("abandon", true))
		}
	})
}

// UnmarshalJSON unmarshals the ResourceRpcPacket from JSON.
func (x *ResourceRpcPacket) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceRpcInit message to JSON.
func (x *ResourceRpcInit) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ResourceId != 0 || s.HasField("resourceId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("resourceId")
		s.WriteUint32(x.ResourceId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceRpcInit to JSON.
func (x *ResourceRpcInit) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceRpcInit message from JSON.
func (x *ResourceRpcInit) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "resource_id", "resourceId":
			s.AddField("resource_id")
			x.ResourceId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceRpcInit from JSON.
func (x *ResourceRpcInit) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceRpcAck message to JSON.
func (x *ResourceRpcAck) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Failure != nil || s.HasField("failure") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("failure")
		x.Failure.MarshalProtoJSON(s.WithField("failure"))
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceRpcAck to JSON.
func (x *ResourceRpcAck) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceRpcAck message from JSON.
func (x *ResourceRpcAck) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "failure":
			if s.ReadNil() {
				x.Failure = nil
				return
			}
			x.Failure = &ResourceFailure{}
			x.Failure.UnmarshalProtoJSON(s.WithField("failure", true))
		}
	})
}

// UnmarshalJSON unmarshals the ResourceRpcAck from JSON.
func (x *ResourceRpcAck) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceRpcAbandon message to JSON.
func (x *ResourceRpcAbandon) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceRpcAbandon to JSON.
func (x *ResourceRpcAbandon) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceRpcAbandon message from JSON.
func (x *ResourceRpcAbandon) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		// no fields
	})
}

// UnmarshalJSON unmarshals the ResourceRpcAbandon from JSON.
func (x *ResourceRpcAbandon) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceClientRequest message to JSON.
func (x *ResourceClientRequest) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Body != nil {
		switch ov := x.Body.(type) {
		case *ResourceClientRequest_Init:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("init")
			ov.Init.MarshalProtoJSON(s.WithField("init"))
		case *ResourceClientRequest_Adopt:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("adopt")
			ov.Adopt.MarshalProtoJSON(s.WithField("adopt"))
		case *ResourceClientRequest_Release:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("release")
			ov.Release.MarshalProtoJSON(s.WithField("release"))
		}
	}
	if x.ControlId != 0 || s.HasField("controlId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("controlId")
		s.WriteUint32(x.ControlId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceClientRequest to JSON.
func (x *ResourceClientRequest) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceClientRequest message from JSON.
func (x *ResourceClientRequest) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "init":
			ov := &ResourceClientRequest_Init{}
			x.Body = ov
			if s.ReadNil() {
				ov.Init = nil
				return
			}
			ov.Init = &ResourceClientInitRequest{}
			ov.Init.UnmarshalProtoJSON(s.WithField("init", true))
		case "adopt":
			ov := &ResourceClientRequest_Adopt{}
			x.Body = ov
			if s.ReadNil() {
				ov.Adopt = nil
				return
			}
			ov.Adopt = &ResourceClientAdopt{}
			ov.Adopt.UnmarshalProtoJSON(s.WithField("adopt", true))
		case "release":
			ov := &ResourceClientRequest_Release{}
			x.Body = ov
			if s.ReadNil() {
				ov.Release = nil
				return
			}
			ov.Release = &ResourceClientRelease{}
			ov.Release.UnmarshalProtoJSON(s.WithField("release", true))
		case "control_id", "controlId":
			s.AddField("control_id")
			x.ControlId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceClientRequest from JSON.
func (x *ResourceClientRequest) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceClientInitRequest message to JSON.
func (x *ResourceClientInitRequest) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceClientInitRequest to JSON.
func (x *ResourceClientInitRequest) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceClientInitRequest message from JSON.
func (x *ResourceClientInitRequest) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		// no fields
	})
}

// UnmarshalJSON unmarshals the ResourceClientInitRequest from JSON.
func (x *ResourceClientInitRequest) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceClientAdopt message to JSON.
func (x *ResourceClientAdopt) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ResourceId != 0 || s.HasField("resourceId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("resourceId")
		s.WriteUint32(x.ResourceId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceClientAdopt to JSON.
func (x *ResourceClientAdopt) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceClientAdopt message from JSON.
func (x *ResourceClientAdopt) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "resource_id", "resourceId":
			s.AddField("resource_id")
			x.ResourceId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceClientAdopt from JSON.
func (x *ResourceClientAdopt) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceClientRelease message to JSON.
func (x *ResourceClientRelease) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ResourceId != 0 || s.HasField("resourceId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("resourceId")
		s.WriteUint32(x.ResourceId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceClientRelease to JSON.
func (x *ResourceClientRelease) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceClientRelease message from JSON.
func (x *ResourceClientRelease) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "resource_id", "resourceId":
			s.AddField("resource_id")
			x.ResourceId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceClientRelease from JSON.
func (x *ResourceClientRelease) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceClientResponse message to JSON.
func (x *ResourceClientResponse) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Body != nil {
		switch ov := x.Body.(type) {
		case *ResourceClientResponse_Init:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("init")
			ov.Init.MarshalProtoJSON(s.WithField("init"))
		case *ResourceClientResponse_ResourceReleased:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("resourceReleased")
			ov.ResourceReleased.MarshalProtoJSON(s.WithField("resourceReleased"))
		case *ResourceClientResponse_ControlAck:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("controlAck")
			ov.ControlAck.MarshalProtoJSON(s.WithField("controlAck"))
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceClientResponse to JSON.
func (x *ResourceClientResponse) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceClientResponse message from JSON.
func (x *ResourceClientResponse) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "init":
			ov := &ResourceClientResponse_Init{}
			x.Body = ov
			if s.ReadNil() {
				ov.Init = nil
				return
			}
			ov.Init = &ResourceClientInit{}
			ov.Init.UnmarshalProtoJSON(s.WithField("init", true))
		case "resource_released", "resourceReleased":
			ov := &ResourceClientResponse_ResourceReleased{}
			x.Body = ov
			if s.ReadNil() {
				ov.ResourceReleased = nil
				return
			}
			ov.ResourceReleased = &ResourceReleasedResponse{}
			ov.ResourceReleased.UnmarshalProtoJSON(s.WithField("resource_released", true))
		case "control_ack", "controlAck":
			ov := &ResourceClientResponse_ControlAck{}
			x.Body = ov
			if s.ReadNil() {
				ov.ControlAck = nil
				return
			}
			ov.ControlAck = &ResourceClientControlAck{}
			ov.ControlAck.UnmarshalProtoJSON(s.WithField("control_ack", true))
		}
	})
}

// UnmarshalJSON unmarshals the ResourceClientResponse from JSON.
func (x *ResourceClientResponse) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceClientControlAck message to JSON.
func (x *ResourceClientControlAck) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ControlId != 0 || s.HasField("controlId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("controlId")
		s.WriteUint32(x.ControlId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceClientControlAck to JSON.
func (x *ResourceClientControlAck) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceClientControlAck message from JSON.
func (x *ResourceClientControlAck) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "control_id", "controlId":
			s.AddField("control_id")
			x.ControlId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceClientControlAck from JSON.
func (x *ResourceClientControlAck) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceReleasedResponse message to JSON.
func (x *ResourceReleasedResponse) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ResourceId != 0 || s.HasField("resourceId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("resourceId")
		s.WriteUint32(x.ResourceId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceReleasedResponse to JSON.
func (x *ResourceReleasedResponse) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceReleasedResponse message from JSON.
func (x *ResourceReleasedResponse) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "resource_id", "resourceId":
			s.AddField("resource_id")
			x.ResourceId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceReleasedResponse from JSON.
func (x *ResourceReleasedResponse) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceClientInit message to JSON.
func (x *ResourceClientInit) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ClientHandleId != 0 || s.HasField("clientHandleId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("clientHandleId")
		s.WriteUint32(x.ClientHandleId)
	}
	if x.RootResourceId != 0 || s.HasField("rootResourceId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rootResourceId")
		s.WriteUint32(x.RootResourceId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceClientInit to JSON.
func (x *ResourceClientInit) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceClientInit message from JSON.
func (x *ResourceClientInit) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "client_handle_id", "clientHandleId":
			s.AddField("client_handle_id")
			x.ClientHandleId = s.ReadUint32()
		case "root_resource_id", "rootResourceId":
			s.AddField("root_resource_id")
			x.RootResourceId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceClientInit from JSON.
func (x *ResourceClientInit) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceAttachRequest message to JSON.
func (x *ResourceAttachRequest) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Body != nil {
		switch ov := x.Body.(type) {
		case *ResourceAttachRequest_Init:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("init")
			ov.Init.MarshalProtoJSON(s.WithField("init"))
		case *ResourceAttachRequest_Add:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("add")
			ov.Add.MarshalProtoJSON(s.WithField("add"))
		case *ResourceAttachRequest_Detach:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("detach")
			ov.Detach.MarshalProtoJSON(s.WithField("detach"))
		case *ResourceAttachRequest_MuxData:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("muxData")
			s.WriteBytes(ov.MuxData)
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceAttachRequest to JSON.
func (x *ResourceAttachRequest) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceAttachRequest message from JSON.
func (x *ResourceAttachRequest) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "init":
			ov := &ResourceAttachRequest_Init{}
			x.Body = ov
			if s.ReadNil() {
				ov.Init = nil
				return
			}
			ov.Init = &ResourceAttachInit{}
			ov.Init.UnmarshalProtoJSON(s.WithField("init", true))
		case "add":
			ov := &ResourceAttachRequest_Add{}
			x.Body = ov
			if s.ReadNil() {
				ov.Add = nil
				return
			}
			ov.Add = &ResourceAttachAdd{}
			ov.Add.UnmarshalProtoJSON(s.WithField("add", true))
		case "detach":
			ov := &ResourceAttachRequest_Detach{}
			x.Body = ov
			if s.ReadNil() {
				ov.Detach = nil
				return
			}
			ov.Detach = &ResourceAttachDetach{}
			ov.Detach.UnmarshalProtoJSON(s.WithField("detach", true))
		case "mux_data", "muxData":
			s.AddField("mux_data")
			ov := &ResourceAttachRequest_MuxData{}
			x.Body = ov
			ov.MuxData = s.ReadBytes()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceAttachRequest from JSON.
func (x *ResourceAttachRequest) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceAttachResponse message to JSON.
func (x *ResourceAttachResponse) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Body != nil {
		switch ov := x.Body.(type) {
		case *ResourceAttachResponse_Ack:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("ack")
			ov.Ack.MarshalProtoJSON(s.WithField("ack"))
		case *ResourceAttachResponse_AddAck:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("addAck")
			ov.AddAck.MarshalProtoJSON(s.WithField("addAck"))
		case *ResourceAttachResponse_DetachAck:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("detachAck")
			ov.DetachAck.MarshalProtoJSON(s.WithField("detachAck"))
		case *ResourceAttachResponse_MuxData:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("muxData")
			s.WriteBytes(ov.MuxData)
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceAttachResponse to JSON.
func (x *ResourceAttachResponse) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceAttachResponse message from JSON.
func (x *ResourceAttachResponse) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "ack":
			ov := &ResourceAttachResponse_Ack{}
			x.Body = ov
			if s.ReadNil() {
				ov.Ack = nil
				return
			}
			ov.Ack = &ResourceAttachAck{}
			ov.Ack.UnmarshalProtoJSON(s.WithField("ack", true))
		case "add_ack", "addAck":
			ov := &ResourceAttachResponse_AddAck{}
			x.Body = ov
			if s.ReadNil() {
				ov.AddAck = nil
				return
			}
			ov.AddAck = &ResourceAttachAddAck{}
			ov.AddAck.UnmarshalProtoJSON(s.WithField("add_ack", true))
		case "detach_ack", "detachAck":
			ov := &ResourceAttachResponse_DetachAck{}
			x.Body = ov
			if s.ReadNil() {
				ov.DetachAck = nil
				return
			}
			ov.DetachAck = &ResourceAttachDetachAck{}
			ov.DetachAck.UnmarshalProtoJSON(s.WithField("detach_ack", true))
		case "mux_data", "muxData":
			s.AddField("mux_data")
			ov := &ResourceAttachResponse_MuxData{}
			x.Body = ov
			ov.MuxData = s.ReadBytes()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceAttachResponse from JSON.
func (x *ResourceAttachResponse) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceAttachInit message to JSON.
func (x *ResourceAttachInit) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ClientHandleId != 0 || s.HasField("clientHandleId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("clientHandleId")
		s.WriteUint32(x.ClientHandleId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceAttachInit to JSON.
func (x *ResourceAttachInit) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceAttachInit message from JSON.
func (x *ResourceAttachInit) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "client_handle_id", "clientHandleId":
			s.AddField("client_handle_id")
			x.ClientHandleId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceAttachInit from JSON.
func (x *ResourceAttachInit) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceAttachAck message to JSON.
func (x *ResourceAttachAck) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Failure != nil || s.HasField("failure") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("failure")
		x.Failure.MarshalProtoJSON(s.WithField("failure"))
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceAttachAck to JSON.
func (x *ResourceAttachAck) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceAttachAck message from JSON.
func (x *ResourceAttachAck) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "failure":
			if s.ReadNil() {
				x.Failure = nil
				return
			}
			x.Failure = &ResourceFailure{}
			x.Failure.UnmarshalProtoJSON(s.WithField("failure", true))
		}
	})
}

// UnmarshalJSON unmarshals the ResourceAttachAck from JSON.
func (x *ResourceAttachAck) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceAttachAdd message to JSON.
func (x *ResourceAttachAdd) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.AttachId != 0 || s.HasField("attachId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("attachId")
		s.WriteUint32(x.AttachId)
	}
	if x.Label != "" || s.HasField("label") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("label")
		s.WriteString(x.Label)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceAttachAdd to JSON.
func (x *ResourceAttachAdd) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceAttachAdd message from JSON.
func (x *ResourceAttachAdd) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "attach_id", "attachId":
			s.AddField("attach_id")
			x.AttachId = s.ReadUint32()
		case "label":
			s.AddField("label")
			x.Label = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceAttachAdd from JSON.
func (x *ResourceAttachAdd) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceAttachAddAck message to JSON.
func (x *ResourceAttachAddAck) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.AttachId != 0 || s.HasField("attachId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("attachId")
		s.WriteUint32(x.AttachId)
	}
	if x.Failure != nil || s.HasField("failure") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("failure")
		x.Failure.MarshalProtoJSON(s.WithField("failure"))
	}
	if x.ResourceId != 0 || s.HasField("resourceId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("resourceId")
		s.WriteUint32(x.ResourceId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceAttachAddAck to JSON.
func (x *ResourceAttachAddAck) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceAttachAddAck message from JSON.
func (x *ResourceAttachAddAck) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "attach_id", "attachId":
			s.AddField("attach_id")
			x.AttachId = s.ReadUint32()
		case "failure":
			if s.ReadNil() {
				x.Failure = nil
				return
			}
			x.Failure = &ResourceFailure{}
			x.Failure.UnmarshalProtoJSON(s.WithField("failure", true))
		case "resource_id", "resourceId":
			s.AddField("resource_id")
			x.ResourceId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceAttachAddAck from JSON.
func (x *ResourceAttachAddAck) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceAttachDetach message to JSON.
func (x *ResourceAttachDetach) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ResourceId != 0 || s.HasField("resourceId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("resourceId")
		s.WriteUint32(x.ResourceId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceAttachDetach to JSON.
func (x *ResourceAttachDetach) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceAttachDetach message from JSON.
func (x *ResourceAttachDetach) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "resource_id", "resourceId":
			s.AddField("resource_id")
			x.ResourceId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceAttachDetach from JSON.
func (x *ResourceAttachDetach) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ResourceAttachDetachAck message to JSON.
func (x *ResourceAttachDetachAck) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ResourceId != 0 || s.HasField("resourceId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("resourceId")
		s.WriteUint32(x.ResourceId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ResourceAttachDetachAck to JSON.
func (x *ResourceAttachDetachAck) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ResourceAttachDetachAck message from JSON.
func (x *ResourceAttachDetachAck) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "resource_id", "resourceId":
			s.AddField("resource_id")
			x.ResourceId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ResourceAttachDetachAck from JSON.
func (x *ResourceAttachDetachAck) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

func (m *ResourceFailure) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceFailure) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceFailure) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if len(m.Message) > 0 {
		i = protobuf_go_lite.EncodeString(dAtA, i, m.Message)
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceRpcPacket) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceRpcPacket) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceRpcPacket) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if vtmsg, ok := m.Body.(interface {
		MarshalToSizedBufferVT([]byte) (int, error)
	}); ok {
		size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
	}
	return len(dAtA) - i, nil
}

func (m *ResourceRpcPacket_Init) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceRpcPacket_Init) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Init != nil {
		size, err := m.Init.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0xa
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ResourceRpcPacket_Ack) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceRpcPacket_Ack) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Ack != nil {
		size, err := m.Ack.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *ResourceRpcPacket_Data) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceRpcPacket_Data) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = protobuf_go_lite.EncodeBytes(dAtA, i, m.Data)
	i--
	dAtA[i] = 0x1a
	return len(dAtA) - i, nil
}

func (m *ResourceRpcPacket_Abandon) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceRpcPacket_Abandon) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Abandon != nil {
		size, err := m.Abandon.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x22
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}

func (m *ResourceRpcInit) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceRpcInit) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceRpcInit) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.ResourceId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ResourceId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceRpcAck) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceRpcAck) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceRpcAck) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.Failure != nil {
		size, err := m.Failure.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ResourceRpcAbandon) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceRpcAbandon) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceRpcAbandon) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientRequest) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceClientRequest) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if vtmsg, ok := m.Body.(interface {
		MarshalToSizedBufferVT([]byte) (int, error)
	}); ok {
		size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
	}
	if m.ControlId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ControlId))
		i--
		dAtA[i] = 0x28
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientRequest_Init) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientRequest_Init) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Init != nil {
		size, err := m.Init.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientRequest_Adopt) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientRequest_Adopt) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Adopt != nil {
		size, err := m.Adopt.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x1a
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientRequest_Release) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientRequest_Release) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Release != nil {
		size, err := m.Release.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x22
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientInitRequest) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceClientInitRequest) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientInitRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientAdopt) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceClientAdopt) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientAdopt) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.ResourceId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ResourceId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientRelease) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceClientRelease) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientRelease) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.ResourceId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ResourceId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientResponse) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceClientResponse) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if vtmsg, ok := m.Body.(interface {
		MarshalToSizedBufferVT([]byte) (int, error)
	}); ok {
		size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientResponse_Init) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientResponse_Init) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Init != nil {
		size, err := m.Init.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0xa
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientResponse_ResourceReleased) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientResponse_ResourceReleased) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ResourceReleased != nil {
		size, err := m.ResourceReleased.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientResponse_ControlAck) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientResponse_ControlAck) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ControlAck != nil {
		size, err := m.ControlAck.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x22
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientControlAck) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceClientControlAck) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientControlAck) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.ControlId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ControlId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceReleasedResponse) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceReleasedResponse) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceReleasedResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.ResourceId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ResourceId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceClientInit) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceClientInit) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceClientInit) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.RootResourceId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RootResourceId))
		i--
		dAtA[i] = 0x10
	}
	if m.ClientHandleId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ClientHandleId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachRequest) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceAttachRequest) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if vtmsg, ok := m.Body.(interface {
		MarshalToSizedBufferVT([]byte) (int, error)
	}); ok {
		size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachRequest_Init) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachRequest_Init) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Init != nil {
		size, err := m.Init.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0xa
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachRequest_Add) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachRequest_Add) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Add != nil {
		size, err := m.Add.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachRequest_Detach) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachRequest_Detach) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Detach != nil {
		size, err := m.Detach.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x1a
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachRequest_MuxData) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachRequest_MuxData) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = protobuf_go_lite.EncodeBytes(dAtA, i, m.MuxData)
	i--
	dAtA[i] = 0x22
	return len(dAtA) - i, nil
}

func (m *ResourceAttachResponse) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceAttachResponse) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if vtmsg, ok := m.Body.(interface {
		MarshalToSizedBufferVT([]byte) (int, error)
	}); ok {
		size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachResponse_Ack) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachResponse_Ack) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Ack != nil {
		size, err := m.Ack.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0xa
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachResponse_AddAck) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachResponse_AddAck) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.AddAck != nil {
		size, err := m.AddAck.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachResponse_DetachAck) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachResponse_DetachAck) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DetachAck != nil {
		size, err := m.DetachAck.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x1a
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, 0)
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachResponse_MuxData) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachResponse_MuxData) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = protobuf_go_lite.EncodeBytes(dAtA, i, m.MuxData)
	i--
	dAtA[i] = 0x22
	return len(dAtA) - i, nil
}

func (m *ResourceAttachInit) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceAttachInit) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachInit) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.ClientHandleId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ClientHandleId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachAck) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceAttachAck) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachAck) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.Failure != nil {
		size, err := m.Failure.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachAdd) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceAttachAdd) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachAdd) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if len(m.Label) > 0 {
		i = protobuf_go_lite.EncodeString(dAtA, i, m.Label)
		i--
		dAtA[i] = 0x12
	}
	if m.AttachId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.AttachId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachAddAck) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceAttachAddAck) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachAddAck) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.ResourceId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ResourceId))
		i--
		dAtA[i] = 0x18
	}
	if m.Failure != nil {
		size, err := m.Failure.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	}
	if m.AttachId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.AttachId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachDetach) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceAttachDetach) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachDetach) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.ResourceId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ResourceId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceAttachDetachAck) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceAttachDetachAck) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ResourceAttachDetachAck) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i = protobuf_go_lite.EncodeRawBytes(dAtA, i, m.unknownFields)
	}
	if m.ResourceId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ResourceId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ResourceFailure) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.Code)
	n += protobuf_go_lite.SizeStringNonEmpty(1, m.Message)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceRpcPacket) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if vtmsg, ok := m.Body.(interface{ SizeVT() int }); ok {
		n += vtmsg.SizeVT()
	}
	n += len(m.unknownFields)
	return n
}

func (m *ResourceRpcPacket_Init) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Init != nil {
		l = m.Init.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceRpcPacket_Ack) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ack != nil {
		l = m.Ack.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceRpcPacket_Data) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeBytesValue(1, len(m.Data))
	return n
}

func (m *ResourceRpcPacket_Abandon) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Abandon != nil {
		l = m.Abandon.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceRpcInit) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ResourceId)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceRpcAck) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Failure != nil {
		l = m.Failure.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	}
	n += len(m.unknownFields)
	return n
}

func (m *ResourceRpcAbandon) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += len(m.unknownFields)
	return n
}

func (m *ResourceClientRequest) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if vtmsg, ok := m.Body.(interface{ SizeVT() int }); ok {
		n += vtmsg.SizeVT()
	}
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ControlId)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceClientRequest_Init) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Init != nil {
		l = m.Init.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceClientRequest_Adopt) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Adopt != nil {
		l = m.Adopt.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceClientRequest_Release) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Release != nil {
		l = m.Release.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceClientInitRequest) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += len(m.unknownFields)
	return n
}

func (m *ResourceClientAdopt) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ResourceId)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceClientRelease) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ResourceId)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceClientResponse) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if vtmsg, ok := m.Body.(interface{ SizeVT() int }); ok {
		n += vtmsg.SizeVT()
	}
	n += len(m.unknownFields)
	return n
}

func (m *ResourceClientResponse_Init) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Init != nil {
		l = m.Init.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceClientResponse_ResourceReleased) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResourceReleased != nil {
		l = m.ResourceReleased.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceClientResponse_ControlAck) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ControlAck != nil {
		l = m.ControlAck.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceClientControlAck) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ControlId)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceReleasedResponse) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ResourceId)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceClientInit) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ClientHandleId)
	n += protobuf_go_lite.SizeVarintNonZero(1, m.RootResourceId)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceAttachRequest) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if vtmsg, ok := m.Body.(interface{ SizeVT() int }); ok {
		n += vtmsg.SizeVT()
	}
	n += len(m.unknownFields)
	return n
}

func (m *ResourceAttachRequest_Init) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Init != nil {
		l = m.Init.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceAttachRequest_Add) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Add != nil {
		l = m.Add.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceAttachRequest_Detach) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Detach != nil {
		l = m.Detach.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceAttachRequest_MuxData) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeBytesValue(1, len(m.MuxData))
	return n
}

func (m *ResourceAttachResponse) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if vtmsg, ok := m.Body.(interface{ SizeVT() int }); ok {
		n += vtmsg.SizeVT()
	}
	n += len(m.unknownFields)
	return n
}

func (m *ResourceAttachResponse_Ack) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ack != nil {
		l = m.Ack.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceAttachResponse_AddAck) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AddAck != nil {
		l = m.AddAck.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceAttachResponse_DetachAck) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DetachAck != nil {
		l = m.DetachAck.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	} else {
		n += 2
	}
	return n
}

func (m *ResourceAttachResponse_MuxData) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeBytesValue(1, len(m.MuxData))
	return n
}

func (m *ResourceAttachInit) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ClientHandleId)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceAttachAck) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Failure != nil {
		l = m.Failure.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	}
	n += len(m.unknownFields)
	return n
}

func (m *ResourceAttachAdd) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.AttachId)
	n += protobuf_go_lite.SizeStringNonEmpty(1, m.Label)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceAttachAddAck) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.AttachId)
	if m.Failure != nil {
		l = m.Failure.SizeVT()
		n += protobuf_go_lite.SizeMessage(1, l)
	}
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ResourceId)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceAttachDetach) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ResourceId)
	n += len(m.unknownFields)
	return n
}

func (m *ResourceAttachDetachAck) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += protobuf_go_lite.SizeVarintNonZero(1, m.ResourceId)
	n += len(m.unknownFields)
	return n
}

func (x ResourceFailureCode) MarshalProtoText() string {
	return x.String()
}

func (x *ResourceFailure) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceFailure")
	if x.Code != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "code")
		protobuf_go_lite.TextWriteStringer(&sb, ResourceFailureCode(x.Code))
	}
	if x.Message != "" {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "message")
		protobuf_go_lite.TextWriteString(&sb, x.Message)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceFailure) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceRpcPacket) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceRpcPacket")
	switch body := x.Body.(type) {
	case *ResourceRpcPacket_Init:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "init")
		if body.Init == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceRpcInit{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Init)
		}
	case *ResourceRpcPacket_Ack:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "ack")
		if body.Ack == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceRpcAck{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Ack)
		}
	case *ResourceRpcPacket_Data:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "data")
		protobuf_go_lite.TextWriteBytes(&sb, body.Data)
	case *ResourceRpcPacket_Abandon:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "abandon")
		if body.Abandon == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceRpcAbandon{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Abandon)
		}
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceRpcPacket) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceRpcInit) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceRpcInit")
	if x.ResourceId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "resource_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ResourceId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceRpcInit) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceRpcAck) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceRpcAck")
	if x.Failure != nil {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "failure")
		protobuf_go_lite.TextWriteTextMarshaler(&sb, x.Failure)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceRpcAck) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceRpcAbandon) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	protobuf_go_lite.TextStartMessage(&sb, "ResourceRpcAbandon")
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceRpcAbandon) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceClientRequest) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceClientRequest")
	switch body := x.Body.(type) {
	case *ResourceClientRequest_Init:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "init")
		if body.Init == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceClientInitRequest{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Init)
		}
	case *ResourceClientRequest_Adopt:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "adopt")
		if body.Adopt == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceClientAdopt{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Adopt)
		}
	case *ResourceClientRequest_Release:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "release")
		if body.Release == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceClientRelease{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Release)
		}
	}
	if x.ControlId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "control_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ControlId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceClientRequest) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceClientInitRequest) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	protobuf_go_lite.TextStartMessage(&sb, "ResourceClientInitRequest")
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceClientInitRequest) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceClientAdopt) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceClientAdopt")
	if x.ResourceId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "resource_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ResourceId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceClientAdopt) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceClientRelease) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceClientRelease")
	if x.ResourceId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "resource_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ResourceId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceClientRelease) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceClientResponse) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceClientResponse")
	switch body := x.Body.(type) {
	case *ResourceClientResponse_Init:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "init")
		if body.Init == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceClientInit{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Init)
		}
	case *ResourceClientResponse_ResourceReleased:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "resource_released")
		if body.ResourceReleased == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceReleasedResponse{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.ResourceReleased)
		}
	case *ResourceClientResponse_ControlAck:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "control_ack")
		if body.ControlAck == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceClientControlAck{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.ControlAck)
		}
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceClientResponse) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceClientControlAck) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceClientControlAck")
	if x.ControlId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "control_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ControlId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceClientControlAck) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceReleasedResponse) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceReleasedResponse")
	if x.ResourceId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "resource_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ResourceId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceReleasedResponse) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceClientInit) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceClientInit")
	if x.ClientHandleId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "client_handle_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ClientHandleId)
	}
	if x.RootResourceId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "root_resource_id")
		protobuf_go_lite.TextWriteUint(&sb, x.RootResourceId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceClientInit) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceAttachRequest) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceAttachRequest")
	switch body := x.Body.(type) {
	case *ResourceAttachRequest_Init:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "init")
		if body.Init == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceAttachInit{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Init)
		}
	case *ResourceAttachRequest_Add:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "add")
		if body.Add == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceAttachAdd{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Add)
		}
	case *ResourceAttachRequest_Detach:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "detach")
		if body.Detach == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceAttachDetach{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Detach)
		}
	case *ResourceAttachRequest_MuxData:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "mux_data")
		protobuf_go_lite.TextWriteBytes(&sb, body.MuxData)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceAttachRequest) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceAttachResponse) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceAttachResponse")
	switch body := x.Body.(type) {
	case *ResourceAttachResponse_Ack:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "ack")
		if body.Ack == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceAttachAck{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.Ack)
		}
	case *ResourceAttachResponse_AddAck:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "add_ack")
		if body.AddAck == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceAttachAddAck{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.AddAck)
		}
	case *ResourceAttachResponse_DetachAck:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "detach_ack")
		if body.DetachAck == nil {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, &ResourceAttachDetachAck{})
		} else {
			protobuf_go_lite.TextWriteTextMarshaler(&sb, body.DetachAck)
		}
	case *ResourceAttachResponse_MuxData:
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "mux_data")
		protobuf_go_lite.TextWriteBytes(&sb, body.MuxData)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceAttachResponse) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceAttachInit) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceAttachInit")
	if x.ClientHandleId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "client_handle_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ClientHandleId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceAttachInit) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceAttachAck) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceAttachAck")
	if x.Failure != nil {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "failure")
		protobuf_go_lite.TextWriteTextMarshaler(&sb, x.Failure)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceAttachAck) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceAttachAdd) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceAttachAdd")
	if x.AttachId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "attach_id")
		protobuf_go_lite.TextWriteUint(&sb, x.AttachId)
	}
	if x.Label != "" {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "label")
		protobuf_go_lite.TextWriteString(&sb, x.Label)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceAttachAdd) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceAttachAddAck) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceAttachAddAck")
	if x.AttachId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "attach_id")
		protobuf_go_lite.TextWriteUint(&sb, x.AttachId)
	}
	if x.Failure != nil {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "failure")
		protobuf_go_lite.TextWriteTextMarshaler(&sb, x.Failure)
	}
	if x.ResourceId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "resource_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ResourceId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceAttachAddAck) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceAttachDetach) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceAttachDetach")
	if x.ResourceId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "resource_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ResourceId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceAttachDetach) String() string {
	return x.MarshalProtoText()
}

func (x *ResourceAttachDetachAck) MarshalProtoText() string {
	var sb protobuf_go_lite.TextBuilder
	initialLen := protobuf_go_lite.TextStartMessage(&sb, "ResourceAttachDetachAck")
	if x.ResourceId != 0 {
		protobuf_go_lite.TextWriteFieldPrefix(&sb, initialLen, "resource_id")
		protobuf_go_lite.TextWriteUint(&sb, x.ResourceId)
	}
	return protobuf_go_lite.TextFinishMessage(&sb)
}

func (x *ResourceAttachDetachAck) String() string {
	return x.MarshalProtoText()
}

func (m *ResourceFailure) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceFailure: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceFailure: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			var _v uint64
			_v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			m.Code = ResourceFailureCode(_v)
			if err != nil {
				return err
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var v string
			v, iNdEx, err = protobuf_go_lite.DecodeString(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.Message = v
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceRpcPacket) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceRpcPacket: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceRpcPacket: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Init", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceRpcPacket_Init); ok {
				if err := oneof.Init.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceRpcInit{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceRpcPacket_Init{Init: v}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ack", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceRpcPacket_Ack); ok {
				if err := oneof.Ack.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceRpcAck{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceRpcPacket_Ack{Ack: v}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var v []byte
			v, iNdEx, err = protobuf_go_lite.DecodeBytes(dAtA, iNdEx, true)
			if err != nil {
				return err
			}
			m.Body = &ResourceRpcPacket_Data{Data: v}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Abandon", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceRpcPacket_Abandon); ok {
				if err := oneof.Abandon.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceRpcAbandon{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceRpcPacket_Abandon{Abandon: v}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceRpcInit) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceRpcInit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceRpcInit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceId", wireType)
			}
			m.ResourceId = 0
			m.ResourceId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceRpcAck) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceRpcAck: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceRpcAck: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Failure", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if m.Failure == nil {
				m.Failure = &ResourceFailure{}
			}
			if err := m.Failure.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceRpcAbandon) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceRpcAbandon: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceRpcAbandon: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceClientRequest) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceClientRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceClientRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Init", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceClientRequest_Init); ok {
				if err := oneof.Init.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceClientInitRequest{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceClientRequest_Init{Init: v}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Adopt", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceClientRequest_Adopt); ok {
				if err := oneof.Adopt.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceClientAdopt{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceClientRequest_Adopt{Adopt: v}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Release", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceClientRequest_Release); ok {
				if err := oneof.Release.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceClientRelease{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceClientRequest_Release{Release: v}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlId", wireType)
			}
			m.ControlId = 0
			m.ControlId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceClientInitRequest) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceClientInitRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceClientInitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceClientAdopt) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceClientAdopt: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceClientAdopt: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceId", wireType)
			}
			m.ResourceId = 0
			m.ResourceId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceClientRelease) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceClientRelease: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceClientRelease: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceId", wireType)
			}
			m.ResourceId = 0
			m.ResourceId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceClientResponse) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceClientResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceClientResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Init", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceClientResponse_Init); ok {
				if err := oneof.Init.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceClientInit{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceClientResponse_Init{Init: v}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceReleased", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceClientResponse_ResourceReleased); ok {
				if err := oneof.ResourceReleased.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceReleasedResponse{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceClientResponse_ResourceReleased{ResourceReleased: v}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlAck", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceClientResponse_ControlAck); ok {
				if err := oneof.ControlAck.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceClientControlAck{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceClientResponse_ControlAck{ControlAck: v}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceClientControlAck) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceClientControlAck: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceClientControlAck: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlId", wireType)
			}
			m.ControlId = 0
			m.ControlId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceReleasedResponse) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceReleasedResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceReleasedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceId", wireType)
			}
			m.ResourceId = 0
			m.ResourceId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceClientInit) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceClientInit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceClientInit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientHandleId", wireType)
			}
			m.ClientHandleId = 0
			m.ClientHandleId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootResourceId", wireType)
			}
			m.RootResourceId = 0
			m.RootResourceId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceAttachRequest) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceAttachRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceAttachRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Init", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceAttachRequest_Init); ok {
				if err := oneof.Init.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceAttachInit{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceAttachRequest_Init{Init: v}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Add", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceAttachRequest_Add); ok {
				if err := oneof.Add.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceAttachAdd{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceAttachRequest_Add{Add: v}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Detach", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceAttachRequest_Detach); ok {
				if err := oneof.Detach.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceAttachDetach{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceAttachRequest_Detach{Detach: v}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MuxData", wireType)
			}
			var v []byte
			v, iNdEx, err = protobuf_go_lite.DecodeBytes(dAtA, iNdEx, true)
			if err != nil {
				return err
			}
			m.Body = &ResourceAttachRequest_MuxData{MuxData: v}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceAttachResponse) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceAttachResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceAttachResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ack", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceAttachResponse_Ack); ok {
				if err := oneof.Ack.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceAttachAck{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceAttachResponse_Ack{Ack: v}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddAck", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceAttachResponse_AddAck); ok {
				if err := oneof.AddAck.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceAttachAddAck{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceAttachResponse_AddAck{AddAck: v}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DetachAck", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if oneof, ok := m.Body.(*ResourceAttachResponse_DetachAck); ok {
				if err := oneof.DetachAck.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
			} else {
				v := &ResourceAttachDetachAck{}
				if err := v.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
					return err
				}
				m.Body = &ResourceAttachResponse_DetachAck{DetachAck: v}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MuxData", wireType)
			}
			var v []byte
			v, iNdEx, err = protobuf_go_lite.DecodeBytes(dAtA, iNdEx, true)
			if err != nil {
				return err
			}
			m.Body = &ResourceAttachResponse_MuxData{MuxData: v}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceAttachInit) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceAttachInit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceAttachInit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientHandleId", wireType)
			}
			m.ClientHandleId = 0
			m.ClientHandleId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceAttachAck) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceAttachAck: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceAttachAck: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Failure", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if m.Failure == nil {
				m.Failure = &ResourceFailure{}
			}
			if err := m.Failure.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceAttachAdd) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceAttachAdd: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceAttachAdd: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttachId", wireType)
			}
			m.AttachId = 0
			m.AttachId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
			}
			var v string
			v, iNdEx, err = protobuf_go_lite.DecodeString(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.Label = v
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceAttachAddAck) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceAttachAddAck: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceAttachAddAck: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttachId", wireType)
			}
			m.AttachId = 0
			m.AttachId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Failure", wireType)
			}
			msgStart, postIndex, err := protobuf_go_lite.DecodeLengthDelimited(dAtA, iNdEx)
			if err != nil {
				return err
			}
			if m.Failure == nil {
				m.Failure = &ResourceFailure{}
			}
			if err := m.Failure.UnmarshalVT(dAtA[msgStart:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceId", wireType)
			}
			m.ResourceId = 0
			m.ResourceId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceAttachDetach) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceAttachDetach: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceAttachDetach: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceId", wireType)
			}
			m.ResourceId = 0
			m.ResourceId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ResourceAttachDetachAck) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceAttachDetachAck: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceAttachDetachAck: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceId", wireType)
			}
			m.ResourceId = 0
			m.ResourceId, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}