// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pb/protos/service/service.proto

package service

import (
	"context"
	fmt "fmt"
	pb "github.com/anyproto/anytype-heart/pb"
	proto "github.com/gogo/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

func init() { proto.RegisterFile("pb/protos/service/service.proto", fileDescriptor_93a29dc403579097) }

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the gomobile package it is being compiled against.

// ClientCommandsHandler is the handler API for ClientCommands service.
var clientCommandsHandler ClientCommandsHandler

type ClientCommandsHandler interface {
	AppGetVersion(context.Context, *pb.RpcAppGetVersionRequest) *pb.RpcAppGetVersionResponse
	AppSetDeviceState(context.Context, *pb.RpcAppSetDeviceStateRequest) *pb.RpcAppSetDeviceStateResponse
	AppShutdown(context.Context, *pb.RpcAppShutdownRequest) *pb.RpcAppShutdownResponse
	// Wallet
	// ***
	WalletCreate(context.Context, *pb.RpcWalletCreateRequest) *pb.RpcWalletCreateResponse
	WalletRecover(context.Context, *pb.RpcWalletRecoverRequest) *pb.RpcWalletRecoverResponse
	WalletConvert(context.Context, *pb.RpcWalletConvertRequest) *pb.RpcWalletConvertResponse
	AccountLocalLinkNewChallenge(context.Context, *pb.RpcAccountLocalLinkNewChallengeRequest) *pb.RpcAccountLocalLinkNewChallengeResponse
	AccountLocalLinkSolveChallenge(context.Context, *pb.RpcAccountLocalLinkSolveChallengeRequest) *pb.RpcAccountLocalLinkSolveChallengeResponse
	AccountLocalLinkCreateApp(context.Context, *pb.RpcAccountLocalLinkCreateAppRequest) *pb.RpcAccountLocalLinkCreateAppResponse
	AccountLocalLinkListApps(context.Context, *pb.RpcAccountLocalLinkListAppsRequest) *pb.RpcAccountLocalLinkListAppsResponse
	AccountLocalLinkRevokeApp(context.Context, *pb.RpcAccountLocalLinkRevokeAppRequest) *pb.RpcAccountLocalLinkRevokeAppResponse
	WalletCreateSession(context.Context, *pb.RpcWalletCreateSessionRequest) *pb.RpcWalletCreateSessionResponse
	WalletCloseSession(context.Context, *pb.RpcWalletCloseSessionRequest) *pb.RpcWalletCloseSessionResponse
	// Workspace
	// ***
	WorkspaceCreate(context.Context, *pb.RpcWorkspaceCreateRequest) *pb.RpcWorkspaceCreateResponse
	WorkspaceOpen(context.Context, *pb.RpcWorkspaceOpenRequest) *pb.RpcWorkspaceOpenResponse
	WorkspaceObjectAdd(context.Context, *pb.RpcWorkspaceObjectAddRequest) *pb.RpcWorkspaceObjectAddResponse
	WorkspaceObjectListAdd(context.Context, *pb.RpcWorkspaceObjectListAddRequest) *pb.RpcWorkspaceObjectListAddResponse
	WorkspaceObjectListRemove(context.Context, *pb.RpcWorkspaceObjectListRemoveRequest) *pb.RpcWorkspaceObjectListRemoveResponse
	WorkspaceSelect(context.Context, *pb.RpcWorkspaceSelectRequest) *pb.RpcWorkspaceSelectResponse
	WorkspaceGetCurrent(context.Context, *pb.RpcWorkspaceGetCurrentRequest) *pb.RpcWorkspaceGetCurrentResponse
	WorkspaceGetAll(context.Context, *pb.RpcWorkspaceGetAllRequest) *pb.RpcWorkspaceGetAllResponse
	WorkspaceSetInfo(context.Context, *pb.RpcWorkspaceSetInfoRequest) *pb.RpcWorkspaceSetInfoResponse
	WorkspaceExport(context.Context, *pb.RpcWorkspaceExportRequest) *pb.RpcWorkspaceExportResponse
	// Account
	// ***
	AccountRecover(context.Context, *pb.RpcAccountRecoverRequest) *pb.RpcAccountRecoverResponse
	AccountMigrate(context.Context, *pb.RpcAccountMigrateRequest) *pb.RpcAccountMigrateResponse
	AccountMigrateCancel(context.Context, *pb.RpcAccountMigrateCancelRequest) *pb.RpcAccountMigrateCancelResponse
	AccountCreate(context.Context, *pb.RpcAccountCreateRequest) *pb.RpcAccountCreateResponse
	AccountDelete(context.Context, *pb.RpcAccountDeleteRequest) *pb.RpcAccountDeleteResponse
	AccountRevertDeletion(context.Context, *pb.RpcAccountRevertDeletionRequest) *pb.RpcAccountRevertDeletionResponse
	AccountSelect(context.Context, *pb.RpcAccountSelectRequest) *pb.RpcAccountSelectResponse
	AccountEnableLocalNetworkSync(context.Context, *pb.RpcAccountEnableLocalNetworkSyncRequest) *pb.RpcAccountEnableLocalNetworkSyncResponse
	AccountChangeJsonApiAddr(context.Context, *pb.RpcAccountChangeJsonApiAddrRequest) *pb.RpcAccountChangeJsonApiAddrResponse
	AccountStop(context.Context, *pb.RpcAccountStopRequest) *pb.RpcAccountStopResponse
	AccountMove(context.Context, *pb.RpcAccountMoveRequest) *pb.RpcAccountMoveResponse
	AccountConfigUpdate(context.Context, *pb.RpcAccountConfigUpdateRequest) *pb.RpcAccountConfigUpdateResponse
	AccountRecoverFromLegacyExport(context.Context, *pb.RpcAccountRecoverFromLegacyExportRequest) *pb.RpcAccountRecoverFromLegacyExportResponse
	AccountChangeNetworkConfigAndRestart(context.Context, *pb.RpcAccountChangeNetworkConfigAndRestartRequest) *pb.RpcAccountChangeNetworkConfigAndRestartResponse
	// Space
	// ***
	SpaceDelete(context.Context, *pb.RpcSpaceDeleteRequest) *pb.RpcSpaceDeleteResponse
	SpaceInviteGenerate(context.Context, *pb.RpcSpaceInviteGenerateRequest) *pb.RpcSpaceInviteGenerateResponse
	SpaceInviteChange(context.Context, *pb.RpcSpaceInviteChangeRequest) *pb.RpcSpaceInviteChangeResponse
	SpaceInviteGetCurrent(context.Context, *pb.RpcSpaceInviteGetCurrentRequest) *pb.RpcSpaceInviteGetCurrentResponse
	SpaceInviteGetGuest(context.Context, *pb.RpcSpaceInviteGetGuestRequest) *pb.RpcSpaceInviteGetGuestResponse
	SpaceInviteRevoke(context.Context, *pb.RpcSpaceInviteRevokeRequest) *pb.RpcSpaceInviteRevokeResponse
	SpaceInviteView(context.Context, *pb.RpcSpaceInviteViewRequest) *pb.RpcSpaceInviteViewResponse
	SpaceJoin(context.Context, *pb.RpcSpaceJoinRequest) *pb.RpcSpaceJoinResponse
	SpaceJoinCancel(context.Context, *pb.RpcSpaceJoinCancelRequest) *pb.RpcSpaceJoinCancelResponse
	SpaceStopSharing(context.Context, *pb.RpcSpaceStopSharingRequest) *pb.RpcSpaceStopSharingResponse
	SpaceRequestApprove(context.Context, *pb.RpcSpaceRequestApproveRequest) *pb.RpcSpaceRequestApproveResponse
	SpaceRequestDecline(context.Context, *pb.RpcSpaceRequestDeclineRequest) *pb.RpcSpaceRequestDeclineResponse
	SpaceLeaveApprove(context.Context, *pb.RpcSpaceLeaveApproveRequest) *pb.RpcSpaceLeaveApproveResponse
	SpaceMakeShareable(context.Context, *pb.RpcSpaceMakeShareableRequest) *pb.RpcSpaceMakeShareableResponse
	SpaceParticipantRemove(context.Context, *pb.RpcSpaceParticipantRemoveRequest) *pb.RpcSpaceParticipantRemoveResponse
	SpaceParticipantPermissionsChange(context.Context, *pb.RpcSpaceParticipantPermissionsChangeRequest) *pb.RpcSpaceParticipantPermissionsChangeResponse
	SpaceSetOrder(context.Context, *pb.RpcSpaceSetOrderRequest) *pb.RpcSpaceSetOrderResponse
	SpaceUnsetOrder(context.Context, *pb.RpcSpaceUnsetOrderRequest) *pb.RpcSpaceUnsetOrderResponse
	// Publishing
	// ***
	PublishingCreate(context.Context, *pb.RpcPublishingCreateRequest) *pb.RpcPublishingCreateResponse
	PublishingRemove(context.Context, *pb.RpcPublishingRemoveRequest) *pb.RpcPublishingRemoveResponse
	PublishingList(context.Context, *pb.RpcPublishingListRequest) *pb.RpcPublishingListResponse
	PublishingResolveUri(context.Context, *pb.RpcPublishingResolveUriRequest) *pb.RpcPublishingResolveUriResponse
	PublishingGetStatus(context.Context, *pb.RpcPublishingGetStatusRequest) *pb.RpcPublishingGetStatusResponse
	// Object
	// ***
	ObjectOpen(context.Context, *pb.RpcObjectOpenRequest) *pb.RpcObjectOpenResponse
	ObjectRefresh(context.Context, *pb.RpcObjectRefreshRequest) *pb.RpcObjectRefreshResponse
	ObjectClose(context.Context, *pb.RpcObjectCloseRequest) *pb.RpcObjectCloseResponse
	ObjectShow(context.Context, *pb.RpcObjectShowRequest) *pb.RpcObjectShowResponse
	// ObjectCreate just creates the new page, without adding the link to it from some other page
	ObjectCreate(context.Context, *pb.RpcObjectCreateRequest) *pb.RpcObjectCreateResponse
	ObjectCreateBookmark(context.Context, *pb.RpcObjectCreateBookmarkRequest) *pb.RpcObjectCreateBookmarkResponse
	ObjectCreateFromUrl(context.Context, *pb.RpcObjectCreateFromUrlRequest) *pb.RpcObjectCreateFromUrlResponse
	// ObjectCreateSet just creates the new set, without adding the link to it from some other page
	ObjectCreateSet(context.Context, *pb.RpcObjectCreateSetRequest) *pb.RpcObjectCreateSetResponse
	ObjectGraph(context.Context, *pb.RpcObjectGraphRequest) *pb.RpcObjectGraphResponse
	ObjectSearch(context.Context, *pb.RpcObjectSearchRequest) *pb.RpcObjectSearchResponse
	ObjectSearchWithMeta(context.Context, *pb.RpcObjectSearchWithMetaRequest) *pb.RpcObjectSearchWithMetaResponse
	ObjectSearchSubscribe(context.Context, *pb.RpcObjectSearchSubscribeRequest) *pb.RpcObjectSearchSubscribeResponse
	ObjectCrossSpaceSearchSubscribe(context.Context, *pb.RpcObjectCrossSpaceSearchSubscribeRequest) *pb.RpcObjectCrossSpaceSearchSubscribeResponse
	ObjectCrossSpaceSearchUnsubscribe(context.Context, *pb.RpcObjectCrossSpaceSearchUnsubscribeRequest) *pb.RpcObjectCrossSpaceSearchUnsubscribeResponse
	ObjectSubscribeIds(context.Context, *pb.RpcObjectSubscribeIdsRequest) *pb.RpcObjectSubscribeIdsResponse
	ObjectGroupsSubscribe(context.Context, *pb.RpcObjectGroupsSubscribeRequest) *pb.RpcObjectGroupsSubscribeResponse
	ObjectSearchUnsubscribe(context.Context, *pb.RpcObjectSearchUnsubscribeRequest) *pb.RpcObjectSearchUnsubscribeResponse
	ObjectSetDetails(context.Context, *pb.RpcObjectSetDetailsRequest) *pb.RpcObjectSetDetailsResponse
	ObjectDuplicate(context.Context, *pb.RpcObjectDuplicateRequest) *pb.RpcObjectDuplicateResponse
	// ObjectSetObjectType sets an existing object type to the object so it will appear in sets and suggests relations from this type
	ObjectSetObjectType(context.Context, *pb.RpcObjectSetObjectTypeRequest) *pb.RpcObjectSetObjectTypeResponse
	ObjectSetLayout(context.Context, *pb.RpcObjectSetLayoutRequest) *pb.RpcObjectSetLayoutResponse
	ObjectSetInternalFlags(context.Context, *pb.RpcObjectSetInternalFlagsRequest) *pb.RpcObjectSetInternalFlagsResponse
	ObjectSetIsFavorite(context.Context, *pb.RpcObjectSetIsFavoriteRequest) *pb.RpcObjectSetIsFavoriteResponse
	ObjectSetIsArchived(context.Context, *pb.RpcObjectSetIsArchivedRequest) *pb.RpcObjectSetIsArchivedResponse
	ObjectSetSource(context.Context, *pb.RpcObjectSetSourceRequest) *pb.RpcObjectSetSourceResponse
	ObjectWorkspaceSetDashboard(context.Context, *pb.RpcObjectWorkspaceSetDashboardRequest) *pb.RpcObjectWorkspaceSetDashboardResponse
	ObjectListDuplicate(context.Context, *pb.RpcObjectListDuplicateRequest) *pb.RpcObjectListDuplicateResponse
	ObjectListDelete(context.Context, *pb.RpcObjectListDeleteRequest) *pb.RpcObjectListDeleteResponse
	ObjectListSetIsArchived(context.Context, *pb.RpcObjectListSetIsArchivedRequest) *pb.RpcObjectListSetIsArchivedResponse
	ObjectListSetIsFavorite(context.Context, *pb.RpcObjectListSetIsFavoriteRequest) *pb.RpcObjectListSetIsFavoriteResponse
	ObjectListSetObjectType(context.Context, *pb.RpcObjectListSetObjectTypeRequest) *pb.RpcObjectListSetObjectTypeResponse
	ObjectListSetDetails(context.Context, *pb.RpcObjectListSetDetailsRequest) *pb.RpcObjectListSetDetailsResponse
	ObjectListModifyDetailValues(context.Context, *pb.RpcObjectListModifyDetailValuesRequest) *pb.RpcObjectListModifyDetailValuesResponse
	ObjectApplyTemplate(context.Context, *pb.RpcObjectApplyTemplateRequest) *pb.RpcObjectApplyTemplateResponse
	// ObjectToSet creates new set from given object and removes object
	ObjectToSet(context.Context, *pb.RpcObjectToSetRequest) *pb.RpcObjectToSetResponse
	ObjectToCollection(context.Context, *pb.RpcObjectToCollectionRequest) *pb.RpcObjectToCollectionResponse
	ObjectShareByLink(context.Context, *pb.RpcObjectShareByLinkRequest) *pb.RpcObjectShareByLinkResponse
	ObjectUndo(context.Context, *pb.RpcObjectUndoRequest) *pb.RpcObjectUndoResponse
	ObjectRedo(context.Context, *pb.RpcObjectRedoRequest) *pb.RpcObjectRedoResponse
	ObjectListExport(context.Context, *pb.RpcObjectListExportRequest) *pb.RpcObjectListExportResponse
	ObjectExport(context.Context, *pb.RpcObjectExportRequest) *pb.RpcObjectExportResponse
	ObjectBookmarkFetch(context.Context, *pb.RpcObjectBookmarkFetchRequest) *pb.RpcObjectBookmarkFetchResponse
	ObjectImport(context.Context, *pb.RpcObjectImportRequest) *pb.RpcObjectImportResponse
	ObjectImportList(context.Context, *pb.RpcObjectImportListRequest) *pb.RpcObjectImportListResponse
	ObjectImportNotionValidateToken(context.Context, *pb.RpcObjectImportNotionValidateTokenRequest) *pb.RpcObjectImportNotionValidateTokenResponse
	ObjectImportUseCase(context.Context, *pb.RpcObjectImportUseCaseRequest) *pb.RpcObjectImportUseCaseResponse
	ObjectImportExperience(context.Context, *pb.RpcObjectImportExperienceRequest) *pb.RpcObjectImportExperienceResponse
	ObjectDateByTimestamp(context.Context, *pb.RpcObjectDateByTimestampRequest) *pb.RpcObjectDateByTimestampResponse
	// Collections
	// ***
	ObjectCollectionAdd(context.Context, *pb.RpcObjectCollectionAddRequest) *pb.RpcObjectCollectionAddResponse
	ObjectCollectionRemove(context.Context, *pb.RpcObjectCollectionRemoveRequest) *pb.RpcObjectCollectionRemoveResponse
	ObjectCollectionSort(context.Context, *pb.RpcObjectCollectionSortRequest) *pb.RpcObjectCollectionSortResponse
	// Relations
	// ***
	ObjectCreateRelation(context.Context, *pb.RpcObjectCreateRelationRequest) *pb.RpcObjectCreateRelationResponse
	ObjectCreateRelationOption(context.Context, *pb.RpcObjectCreateRelationOptionRequest) *pb.RpcObjectCreateRelationOptionResponse
	RelationListRemoveOption(context.Context, *pb.RpcRelationListRemoveOptionRequest) *pb.RpcRelationListRemoveOptionResponse
	RelationOptions(context.Context, *pb.RpcRelationOptionsRequest) *pb.RpcRelationOptionsResponse
	RelationOptionSetOrder(context.Context, *pb.RpcRelationOptionSetOrderRequest) *pb.RpcRelationOptionSetOrderResponse
	RelationListWithValue(context.Context, *pb.RpcRelationListWithValueRequest) *pb.RpcRelationListWithValueResponse
	// Object Relations
	// ***
	ObjectRelationAdd(context.Context, *pb.RpcObjectRelationAddRequest) *pb.RpcObjectRelationAddResponse
	ObjectRelationDelete(context.Context, *pb.RpcObjectRelationDeleteRequest) *pb.RpcObjectRelationDeleteResponse
	ObjectRelationAddFeatured(context.Context, *pb.RpcObjectRelationAddFeaturedRequest) *pb.RpcObjectRelationAddFeaturedResponse
	ObjectRelationRemoveFeatured(context.Context, *pb.RpcObjectRelationRemoveFeaturedRequest) *pb.RpcObjectRelationRemoveFeaturedResponse
	ObjectRelationListAvailable(context.Context, *pb.RpcObjectRelationListAvailableRequest) *pb.RpcObjectRelationListAvailableResponse
	// ObjectType commands
	// ***
	ObjectCreateObjectType(context.Context, *pb.RpcObjectCreateObjectTypeRequest) *pb.RpcObjectCreateObjectTypeResponse
	ObjectTypeRelationAdd(context.Context, *pb.RpcObjectTypeRelationAddRequest) *pb.RpcObjectTypeRelationAddResponse
	ObjectTypeRelationRemove(context.Context, *pb.RpcObjectTypeRelationRemoveRequest) *pb.RpcObjectTypeRelationRemoveResponse
	ObjectTypeRecommendedRelationsSet(context.Context, *pb.RpcObjectTypeRecommendedRelationsSetRequest) *pb.RpcObjectTypeRecommendedRelationsSetResponse
	ObjectTypeRecommendedFeaturedRelationsSet(context.Context, *pb.RpcObjectTypeRecommendedFeaturedRelationsSetRequest) *pb.RpcObjectTypeRecommendedFeaturedRelationsSetResponse
	ObjectTypeListConflictingRelations(context.Context, *pb.RpcObjectTypeListConflictingRelationsRequest) *pb.RpcObjectTypeListConflictingRelationsResponse
	ObjectTypeResolveLayoutConflicts(context.Context, *pb.RpcObjectTypeResolveLayoutConflictsRequest) *pb.RpcObjectTypeResolveLayoutConflictsResponse
	ObjectTypeSetOrder(context.Context, *pb.RpcObjectTypeSetOrderRequest) *pb.RpcObjectTypeSetOrderResponse
	HistoryShowVersion(context.Context, *pb.RpcHistoryShowVersionRequest) *pb.RpcHistoryShowVersionResponse
	HistoryGetVersions(context.Context, *pb.RpcHistoryGetVersionsRequest) *pb.RpcHistoryGetVersionsResponse
	HistorySetVersion(context.Context, *pb.RpcHistorySetVersionRequest) *pb.RpcHistorySetVersionResponse
	HistoryDiffVersions(context.Context, *pb.RpcHistoryDiffVersionsRequest) *pb.RpcHistoryDiffVersionsResponse
	// Files
	// ***
	FileSpaceOffload(context.Context, *pb.RpcFileSpaceOffloadRequest) *pb.RpcFileSpaceOffloadResponse
	FileReconcile(context.Context, *pb.RpcFileReconcileRequest) *pb.RpcFileReconcileResponse
	FileListOffload(context.Context, *pb.RpcFileListOffloadRequest) *pb.RpcFileListOffloadResponse
	FileUpload(context.Context, *pb.RpcFileUploadRequest) *pb.RpcFileUploadResponse
	FileDownload(context.Context, *pb.RpcFileDownloadRequest) *pb.RpcFileDownloadResponse
	FileDiscardPreload(context.Context, *pb.RpcFileDiscardPreloadRequest) *pb.RpcFileDiscardPreloadResponse
	FileDrop(context.Context, *pb.RpcFileDropRequest) *pb.RpcFileDropResponse
	FileSpaceUsage(context.Context, *pb.RpcFileSpaceUsageRequest) *pb.RpcFileSpaceUsageResponse
	FileNodeUsage(context.Context, *pb.RpcFileNodeUsageRequest) *pb.RpcFileNodeUsageResponse
	NavigationListObjects(context.Context, *pb.RpcNavigationListObjectsRequest) *pb.RpcNavigationListObjectsResponse
	NavigationGetObjectInfoWithLinks(context.Context, *pb.RpcNavigationGetObjectInfoWithLinksRequest) *pb.RpcNavigationGetObjectInfoWithLinksResponse
	TemplateCreateFromObject(context.Context, *pb.RpcTemplateCreateFromObjectRequest) *pb.RpcTemplateCreateFromObjectResponse
	TemplateClone(context.Context, *pb.RpcTemplateCloneRequest) *pb.RpcTemplateCloneResponse
	TemplateExportAll(context.Context, *pb.RpcTemplateExportAllRequest) *pb.RpcTemplateExportAllResponse
	LinkPreview(context.Context, *pb.RpcLinkPreviewRequest) *pb.RpcLinkPreviewResponse
	UnsplashSearch(context.Context, *pb.RpcUnsplashSearchRequest) *pb.RpcUnsplashSearchResponse
	// UnsplashDownload downloads picture from unsplash by ID, put it to the IPFS and returns the hash.
	// The artist info is available in the object details
	UnsplashDownload(context.Context, *pb.RpcUnsplashDownloadRequest) *pb.RpcUnsplashDownloadResponse
	GalleryDownloadManifest(context.Context, *pb.RpcGalleryDownloadManifestRequest) *pb.RpcGalleryDownloadManifestResponse
	GalleryDownloadIndex(context.Context, *pb.RpcGalleryDownloadIndexRequest) *pb.RpcGalleryDownloadIndexResponse
	// General Block commands
	// ***
	BlockUpload(context.Context, *pb.RpcBlockUploadRequest) *pb.RpcBlockUploadResponse
	BlockReplace(context.Context, *pb.RpcBlockReplaceRequest) *pb.RpcBlockReplaceResponse
	BlockCreate(context.Context, *pb.RpcBlockCreateRequest) *pb.RpcBlockCreateResponse
	BlockSplit(context.Context, *pb.RpcBlockSplitRequest) *pb.RpcBlockSplitResponse
	BlockMerge(context.Context, *pb.RpcBlockMergeRequest) *pb.RpcBlockMergeResponse
	BlockCopy(context.Context, *pb.RpcBlockCopyRequest) *pb.RpcBlockCopyResponse
	BlockPaste(context.Context, *pb.RpcBlockPasteRequest) *pb.RpcBlockPasteResponse
	BlockCut(context.Context, *pb.RpcBlockCutRequest) *pb.RpcBlockCutResponse
	BlockSetFields(context.Context, *pb.RpcBlockSetFieldsRequest) *pb.RpcBlockSetFieldsResponse
	BlockExport(context.Context, *pb.RpcBlockExportRequest) *pb.RpcBlockExportResponse
	BlockSetCarriage(context.Context, *pb.RpcBlockSetCarriageRequest) *pb.RpcBlockSetCarriageResponse
	BlockPreview(context.Context, *pb.RpcBlockPreviewRequest) *pb.RpcBlockPreviewResponse
	BlockListDelete(context.Context, *pb.RpcBlockListDeleteRequest) *pb.RpcBlockListDeleteResponse
	BlockListMoveToExistingObject(context.Context, *pb.RpcBlockListMoveToExistingObjectRequest) *pb.RpcBlockListMoveToExistingObjectResponse
	BlockListMoveToNewObject(context.Context, *pb.RpcBlockListMoveToNewObjectRequest) *pb.RpcBlockListMoveToNewObjectResponse
	BlockListConvertToObjects(context.Context, *pb.RpcBlockListConvertToObjectsRequest) *pb.RpcBlockListConvertToObjectsResponse
	BlockListSetFields(context.Context, *pb.RpcBlockListSetFieldsRequest) *pb.RpcBlockListSetFieldsResponse
	BlockListDuplicate(context.Context, *pb.RpcBlockListDuplicateRequest) *pb.RpcBlockListDuplicateResponse
	BlockListSetBackgroundColor(context.Context, *pb.RpcBlockListSetBackgroundColorRequest) *pb.RpcBlockListSetBackgroundColorResponse
	BlockListSetAlign(context.Context, *pb.RpcBlockListSetAlignRequest) *pb.RpcBlockListSetAlignResponse
	BlockListSetVerticalAlign(context.Context, *pb.RpcBlockListSetVerticalAlignRequest) *pb.RpcBlockListSetVerticalAlignResponse
	BlockListTurnInto(context.Context, *pb.RpcBlockListTurnIntoRequest) *pb.RpcBlockListTurnIntoResponse
	// Text Block commands
	// ***
	BlockTextSetText(context.Context, *pb.RpcBlockTextSetTextRequest) *pb.RpcBlockTextSetTextResponse
	BlockTextSetColor(context.Context, *pb.RpcBlockTextSetColorRequest) *pb.RpcBlockTextSetColorResponse
	BlockTextSetStyle(context.Context, *pb.RpcBlockTextSetStyleRequest) *pb.RpcBlockTextSetStyleResponse
	BlockTextSetChecked(context.Context, *pb.RpcBlockTextSetCheckedRequest) *pb.RpcBlockTextSetCheckedResponse
	BlockTextSetIcon(context.Context, *pb.RpcBlockTextSetIconRequest) *pb.RpcBlockTextSetIconResponse
	BlockTextListSetColor(context.Context, *pb.RpcBlockTextListSetColorRequest) *pb.RpcBlockTextListSetColorResponse
	BlockTextListSetMark(context.Context, *pb.RpcBlockTextListSetMarkRequest) *pb.RpcBlockTextListSetMarkResponse
	BlockTextListSetStyle(context.Context, *pb.RpcBlockTextListSetStyleRequest) *pb.RpcBlockTextListSetStyleResponse
	BlockTextListClearStyle(context.Context, *pb.RpcBlockTextListClearStyleRequest) *pb.RpcBlockTextListClearStyleResponse
	BlockTextListClearContent(context.Context, *pb.RpcBlockTextListClearContentRequest) *pb.RpcBlockTextListClearContentResponse
	// File block commands
	// ***
	BlockFileSetName(context.Context, *pb.RpcBlockFileSetNameRequest) *pb.RpcBlockFileSetNameResponse
	BlockFileSetTargetObjectId(context.Context, *pb.RpcBlockFileSetTargetObjectIdRequest) *pb.RpcBlockFileSetTargetObjectIdResponse
	BlockImageSetName(context.Context, *pb.RpcBlockImageSetNameRequest) *pb.RpcBlockImageSetNameResponse
	BlockVideoSetName(context.Context, *pb.RpcBlockVideoSetNameRequest) *pb.RpcBlockVideoSetNameResponse
	BlockFileCreateAndUpload(context.Context, *pb.RpcBlockFileCreateAndUploadRequest) *pb.RpcBlockFileCreateAndUploadResponse
	BlockFileListSetStyle(context.Context, *pb.RpcBlockFileListSetStyleRequest) *pb.RpcBlockFileListSetStyleResponse
	// Dataview block commands
	// ***
	BlockDataviewViewCreate(context.Context, *pb.RpcBlockDataviewViewCreateRequest) *pb.RpcBlockDataviewViewCreateResponse
	BlockDataviewViewDelete(context.Context, *pb.RpcBlockDataviewViewDeleteRequest) *pb.RpcBlockDataviewViewDeleteResponse
	BlockDataviewViewUpdate(context.Context, *pb.RpcBlockDataviewViewUpdateRequest) *pb.RpcBlockDataviewViewUpdateResponse
	BlockDataviewViewSetActive(context.Context, *pb.RpcBlockDataviewViewSetActiveRequest) *pb.RpcBlockDataviewViewSetActiveResponse
	BlockDataviewViewSetPosition(context.Context, *pb.RpcBlockDataviewViewSetPositionRequest) *pb.RpcBlockDataviewViewSetPositionResponse
	BlockDataviewSetSource(context.Context, *pb.RpcBlockDataviewSetSourceRequest) *pb.RpcBlockDataviewSetSourceResponse
	BlockDataviewRelationSet(context.Context, *pb.RpcBlockDataviewRelationSetRequest) *pb.RpcBlockDataviewRelationSetResponse
	BlockDataviewRelationAdd(context.Context, *pb.RpcBlockDataviewRelationAddRequest) *pb.RpcBlockDataviewRelationAddResponse
	BlockDataviewRelationDelete(context.Context, *pb.RpcBlockDataviewRelationDeleteRequest) *pb.RpcBlockDataviewRelationDeleteResponse
	BlockDataviewGroupOrderUpdate(context.Context, *pb.RpcBlockDataviewGroupOrderUpdateRequest) *pb.RpcBlockDataviewGroupOrderUpdateResponse
	BlockDataviewObjectOrderUpdate(context.Context, *pb.RpcBlockDataviewObjectOrderUpdateRequest) *pb.RpcBlockDataviewObjectOrderUpdateResponse
	BlockDataviewObjectOrderMove(context.Context, *pb.RpcBlockDataviewObjectOrderMoveRequest) *pb.RpcBlockDataviewObjectOrderMoveResponse
	BlockDataviewCreateFromExistingObject(context.Context, *pb.RpcBlockDataviewCreateFromExistingObjectRequest) *pb.RpcBlockDataviewCreateFromExistingObjectResponse
	BlockDataviewFilterAdd(context.Context, *pb.RpcBlockDataviewFilterAddRequest) *pb.RpcBlockDataviewFilterAddResponse
	BlockDataviewFilterRemove(context.Context, *pb.RpcBlockDataviewFilterRemoveRequest) *pb.RpcBlockDataviewFilterRemoveResponse
	BlockDataviewFilterReplace(context.Context, *pb.RpcBlockDataviewFilterReplaceRequest) *pb.RpcBlockDataviewFilterReplaceResponse
	BlockDataviewFilterSort(context.Context, *pb.RpcBlockDataviewFilterSortRequest) *pb.RpcBlockDataviewFilterSortResponse
	BlockDataviewSortAdd(context.Context, *pb.RpcBlockDataviewSortAddRequest) *pb.RpcBlockDataviewSortAddResponse
	BlockDataviewSortRemove(context.Context, *pb.RpcBlockDataviewSortRemoveRequest) *pb.RpcBlockDataviewSortRemoveResponse
	BlockDataviewSortReplace(context.Context, *pb.RpcBlockDataviewSortReplaceRequest) *pb.RpcBlockDataviewSortReplaceResponse
	BlockDataviewSortSort(context.Context, *pb.RpcBlockDataviewSortSSortRequest) *pb.RpcBlockDataviewSortSSortResponse
	BlockDataviewViewRelationAdd(context.Context, *pb.RpcBlockDataviewViewRelationAddRequest) *pb.RpcBlockDataviewViewRelationAddResponse
	BlockDataviewViewRelationRemove(context.Context, *pb.RpcBlockDataviewViewRelationRemoveRequest) *pb.RpcBlockDataviewViewRelationRemoveResponse
	BlockDataviewViewRelationReplace(context.Context, *pb.RpcBlockDataviewViewRelationReplaceRequest) *pb.RpcBlockDataviewViewRelationReplaceResponse
	BlockDataviewViewRelationSort(context.Context, *pb.RpcBlockDataviewViewRelationSortRequest) *pb.RpcBlockDataviewViewRelationSortResponse
	// Simple table block commands
	// ***
	BlockTableCreate(context.Context, *pb.RpcBlockTableCreateRequest) *pb.RpcBlockTableCreateResponse
	BlockTableExpand(context.Context, *pb.RpcBlockTableExpandRequest) *pb.RpcBlockTableExpandResponse
	BlockTableRowCreate(context.Context, *pb.RpcBlockTableRowCreateRequest) *pb.RpcBlockTableRowCreateResponse
	BlockTableRowDelete(context.Context, *pb.RpcBlockTableRowDeleteRequest) *pb.RpcBlockTableRowDeleteResponse
	BlockTableRowDuplicate(context.Context, *pb.RpcBlockTableRowDuplicateRequest) *pb.RpcBlockTableRowDuplicateResponse
	BlockTableRowSetHeader(context.Context, *pb.RpcBlockTableRowSetHeaderRequest) *pb.RpcBlockTableRowSetHeaderResponse
	BlockTableColumnCreate(context.Context, *pb.RpcBlockTableColumnCreateRequest) *pb.RpcBlockTableColumnCreateResponse
	BlockTableColumnMove(context.Context, *pb.RpcBlockTableColumnMoveRequest) *pb.RpcBlockTableColumnMoveResponse
	BlockTableColumnDelete(context.Context, *pb.RpcBlockTableColumnDeleteRequest) *pb.RpcBlockTableColumnDeleteResponse
	BlockTableColumnDuplicate(context.Context, *pb.RpcBlockTableColumnDuplicateRequest) *pb.RpcBlockTableColumnDuplicateResponse
	BlockTableRowListFill(context.Context, *pb.RpcBlockTableRowListFillRequest) *pb.RpcBlockTableRowListFillResponse
	BlockTableRowListClean(context.Context, *pb.RpcBlockTableRowListCleanRequest) *pb.RpcBlockTableRowListCleanResponse
	BlockTableColumnListFill(context.Context, *pb.RpcBlockTableColumnListFillRequest) *pb.RpcBlockTableColumnListFillResponse
	BlockTableSort(context.Context, *pb.RpcBlockTableSortRequest) *pb.RpcBlockTableSortResponse
	// Widget commands
	// ***
	BlockCreateWidget(context.Context, *pb.RpcBlockCreateWidgetRequest) *pb.RpcBlockCreateWidgetResponse
	BlockWidgetSetTargetId(context.Context, *pb.RpcBlockWidgetSetTargetIdRequest) *pb.RpcBlockWidgetSetTargetIdResponse
	BlockWidgetSetLayout(context.Context, *pb.RpcBlockWidgetSetLayoutRequest) *pb.RpcBlockWidgetSetLayoutResponse
	BlockWidgetSetLimit(context.Context, *pb.RpcBlockWidgetSetLimitRequest) *pb.RpcBlockWidgetSetLimitResponse
	BlockWidgetSetViewId(context.Context, *pb.RpcBlockWidgetSetViewIdRequest) *pb.RpcBlockWidgetSetViewIdResponse
	// Other specific block commands
	// ***
	BlockLinkCreateWithObject(context.Context, *pb.RpcBlockLinkCreateWithObjectRequest) *pb.RpcBlockLinkCreateWithObjectResponse
	BlockLinkListSetAppearance(context.Context, *pb.RpcBlockLinkListSetAppearanceRequest) *pb.RpcBlockLinkListSetAppearanceResponse
	BlockBookmarkFetch(context.Context, *pb.RpcBlockBookmarkFetchRequest) *pb.RpcBlockBookmarkFetchResponse
	BlockBookmarkCreateAndFetch(context.Context, *pb.RpcBlockBookmarkCreateAndFetchRequest) *pb.RpcBlockBookmarkCreateAndFetchResponse
	BlockRelationSetKey(context.Context, *pb.RpcBlockRelationSetKeyRequest) *pb.RpcBlockRelationSetKeyResponse
	BlockRelationAdd(context.Context, *pb.RpcBlockRelationAddRequest) *pb.RpcBlockRelationAddResponse
	BlockDivListSetStyle(context.Context, *pb.RpcBlockDivListSetStyleRequest) *pb.RpcBlockDivListSetStyleResponse
	BlockLatexSetText(context.Context, *pb.RpcBlockLatexSetTextRequest) *pb.RpcBlockLatexSetTextResponse
	ProcessCancel(context.Context, *pb.RpcProcessCancelRequest) *pb.RpcProcessCancelResponse
	ProcessSubscribe(context.Context, *pb.RpcProcessSubscribeRequest) *pb.RpcProcessSubscribeResponse
	ProcessUnsubscribe(context.Context, *pb.RpcProcessUnsubscribeRequest) *pb.RpcProcessUnsubscribeResponse
	LogSend(context.Context, *pb.RpcLogSendRequest) *pb.RpcLogSendResponse
	DebugStat(context.Context, *pb.RpcDebugStatRequest) *pb.RpcDebugStatResponse
	DebugTree(context.Context, *pb.RpcDebugTreeRequest) *pb.RpcDebugTreeResponse
	DebugTreeHeads(context.Context, *pb.RpcDebugTreeHeadsRequest) *pb.RpcDebugTreeHeadsResponse
	DebugSpaceSummary(context.Context, *pb.RpcDebugSpaceSummaryRequest) *pb.RpcDebugSpaceSummaryResponse
	DebugStackGoroutines(context.Context, *pb.RpcDebugStackGoroutinesRequest) *pb.RpcDebugStackGoroutinesResponse
	DebugExportLocalstore(context.Context, *pb.RpcDebugExportLocalstoreRequest) *pb.RpcDebugExportLocalstoreResponse
	DebugPing(context.Context, *pb.RpcDebugPingRequest) *pb.RpcDebugPingResponse
	DebugSubscriptions(context.Context, *pb.RpcDebugSubscriptionsRequest) *pb.RpcDebugSubscriptionsResponse
	DebugOpenedObjects(context.Context, *pb.RpcDebugOpenedObjectsRequest) *pb.RpcDebugOpenedObjectsResponse
	DebugRunProfiler(context.Context, *pb.RpcDebugRunProfilerRequest) *pb.RpcDebugRunProfilerResponse
	DebugAccountSelectTrace(context.Context, *pb.RpcDebugAccountSelectTraceRequest) *pb.RpcDebugAccountSelectTraceResponse
	DebugAnystoreObjectChanges(context.Context, *pb.RpcDebugAnystoreObjectChangesRequest) *pb.RpcDebugAnystoreObjectChangesResponse
	DebugNetCheck(context.Context, *pb.RpcDebugNetCheckRequest) *pb.RpcDebugNetCheckResponse
	DebugExportLog(context.Context, *pb.RpcDebugExportLogRequest) *pb.RpcDebugExportLogResponse
	InitialSetParameters(context.Context, *pb.RpcInitialSetParametersRequest) *pb.RpcInitialSetParametersResponse
	// used only for lib-server via grpc
	// Streams not supported ### ListenSessionEvents(context.Context, *pb.StreamRequest)
	NotificationList(context.Context, *pb.RpcNotificationListRequest) *pb.RpcNotificationListResponse
	NotificationReply(context.Context, *pb.RpcNotificationReplyRequest) *pb.RpcNotificationReplyResponse
	NotificationTest(context.Context, *pb.RpcNotificationTestRequest) *pb.RpcNotificationTestResponse
	// Membership
	// ***
	// Get current subscription status (tier, expiration date, etc.)
	// WARNING: can be cached by Anytype Heart
	MembershipGetStatus(context.Context, *pb.RpcMembershipGetStatusRequest) *pb.RpcMembershipGetStatusResponse
	// Check if the requested name is valid and vacant for the requested tier
	MembershipIsNameValid(context.Context, *pb.RpcMembershipIsNameValidRequest) *pb.RpcMembershipIsNameValidResponse
	// Buy a subscription, will return a payment URL. The user should be redirected to this URL to complete the payment.
	MembershipRegisterPaymentRequest(context.Context, *pb.RpcMembershipRegisterPaymentRequestRequest) *pb.RpcMembershipRegisterPaymentRequestResponse
	// Get a link to the user's subscription management portal. The user should be redirected to this URL to manage their subscription:
	// a) change his billing details
	// b) see payment info, invoices, etc
	// c) cancel the subscription
	MembershipGetPortalLinkUrl(context.Context, *pb.RpcMembershipGetPortalLinkUrlRequest) *pb.RpcMembershipGetPortalLinkUrlResponse
	// Check the current status of the verification email
	MembershipGetVerificationEmailStatus(context.Context, *pb.RpcMembershipGetVerificationEmailStatusRequest) *pb.RpcMembershipGetVerificationEmailStatusResponse
	// Send a verification code to the user's email. The user should enter this code to verify his email.
	MembershipGetVerificationEmail(context.Context, *pb.RpcMembershipGetVerificationEmailRequest) *pb.RpcMembershipGetVerificationEmailResponse
	// Verify the user's email with the code received in the previous step (MembershipGetVerificationEmail)
	MembershipVerifyEmailCode(context.Context, *pb.RpcMembershipVerifyEmailCodeRequest) *pb.RpcMembershipVerifyEmailCodeResponse
	// If your subscription is in PendingRequiresFinalization:
	// please call MembershipFinalize to finish the process
	MembershipFinalize(context.Context, *pb.RpcMembershipFinalizeRequest) *pb.RpcMembershipFinalizeResponse
	MembershipGetTiers(context.Context, *pb.RpcMembershipGetTiersRequest) *pb.RpcMembershipGetTiersResponse
	MembershipVerifyAppStoreReceipt(context.Context, *pb.RpcMembershipVerifyAppStoreReceiptRequest) *pb.RpcMembershipVerifyAppStoreReceiptResponse
	MembershipCodeGetInfo(context.Context, *pb.RpcMembershipCodeGetInfoRequest) *pb.RpcMembershipCodeGetInfoResponse
	MembershipCodeRedeem(context.Context, *pb.RpcMembershipCodeRedeemRequest) *pb.RpcMembershipCodeRedeemResponse
	// Name Service:
	// ***
	// hello.any -> data
	NameServiceUserAccountGet(context.Context, *pb.RpcNameServiceUserAccountGetRequest) *pb.RpcNameServiceUserAccountGetResponse
	NameServiceResolveName(context.Context, *pb.RpcNameServiceResolveNameRequest) *pb.RpcNameServiceResolveNameResponse
	// 12D3KooWA8EXV3KjBxEU5EnsPfneLx84vMWAtTBQBeyooN82KSuS -> hello.any
	NameServiceResolveAnyId(context.Context, *pb.RpcNameServiceResolveAnyIdRequest) *pb.RpcNameServiceResolveAnyIdResponse
	BroadcastPayloadEvent(context.Context, *pb.RpcBroadcastPayloadEventRequest) *pb.RpcBroadcastPayloadEventResponse
	DeviceSetName(context.Context, *pb.RpcDeviceSetNameRequest) *pb.RpcDeviceSetNameResponse
	DeviceList(context.Context, *pb.RpcDeviceListRequest) *pb.RpcDeviceListResponse
	DeviceNetworkStateSet(context.Context, *pb.RpcDeviceNetworkStateSetRequest) *pb.RpcDeviceNetworkStateSetResponse
	// Chats
	ChatAddMessage(context.Context, *pb.RpcChatAddMessageRequest) *pb.RpcChatAddMessageResponse
	ChatEditMessageContent(context.Context, *pb.RpcChatEditMessageContentRequest) *pb.RpcChatEditMessageContentResponse
	ChatToggleMessageReaction(context.Context, *pb.RpcChatToggleMessageReactionRequest) *pb.RpcChatToggleMessageReactionResponse
	ChatDeleteMessage(context.Context, *pb.RpcChatDeleteMessageRequest) *pb.RpcChatDeleteMessageResponse
	ChatGetMessages(context.Context, *pb.RpcChatGetMessagesRequest) *pb.RpcChatGetMessagesResponse
	ChatGetMessagesByIds(context.Context, *pb.RpcChatGetMessagesByIdsRequest) *pb.RpcChatGetMessagesByIdsResponse
	ChatSubscribeLastMessages(context.Context, *pb.RpcChatSubscribeLastMessagesRequest) *pb.RpcChatSubscribeLastMessagesResponse
	ChatUnsubscribe(context.Context, *pb.RpcChatUnsubscribeRequest) *pb.RpcChatUnsubscribeResponse
	ChatReadMessages(context.Context, *pb.RpcChatReadMessagesRequest) *pb.RpcChatReadMessagesResponse
	ChatUnreadMessages(context.Context, *pb.RpcChatUnreadRequest) *pb.RpcChatUnreadResponse
	ChatSubscribeToMessagePreviews(context.Context, *pb.RpcChatSubscribeToMessagePreviewsRequest) *pb.RpcChatSubscribeToMessagePreviewsResponse
	ChatUnsubscribeFromMessagePreviews(context.Context, *pb.RpcChatUnsubscribeFromMessagePreviewsRequest) *pb.RpcChatUnsubscribeFromMessagePreviewsResponse
	ObjectChatAdd(context.Context, *pb.RpcObjectChatAddRequest) *pb.RpcObjectChatAddResponse
	ChatReadAll(context.Context, *pb.RpcChatReadAllRequest) *pb.RpcChatReadAllResponse
	// mock AI RPCs for compatibility between branches. Not implemented in main
	AIWritingTools(context.Context, *pb.RpcAIWritingToolsRequest) *pb.RpcAIWritingToolsResponse
	AIAutofill(context.Context, *pb.RpcAIAutofillRequest) *pb.RpcAIAutofillResponse
	AIListSummary(context.Context, *pb.RpcAIListSummaryRequest) *pb.RpcAIListSummaryResponse
	AIObjectCreateFromUrl(context.Context, *pb.RpcAIObjectCreateFromUrlRequest) *pb.RpcAIObjectCreateFromUrlResponse
	// Push
	PushNotificationRegisterToken(context.Context, *pb.RpcPushNotificationRegisterTokenRequest) *pb.RpcPushNotificationRegisterTokenResponse
	PushNotificationSetSpaceMode(context.Context, *pb.RpcPushNotificationSetSpaceModeRequest) *pb.RpcPushNotificationSetSpaceModeResponse
}

func registerClientCommandsHandler(srv ClientCommandsHandler) {
	clientCommandsHandler = srv
}

func AppGetVersion(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAppGetVersionResponse{Error: &pb.RpcAppGetVersionResponseError{Code: pb.RpcAppGetVersionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAppGetVersionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAppGetVersionResponse{Error: &pb.RpcAppGetVersionResponseError{Code: pb.RpcAppGetVersionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AppGetVersion(context.Background(), in).Marshal()
	return resp
}

func AppSetDeviceState(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAppSetDeviceStateResponse{Error: &pb.RpcAppSetDeviceStateResponseError{Code: pb.RpcAppSetDeviceStateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAppSetDeviceStateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAppSetDeviceStateResponse{Error: &pb.RpcAppSetDeviceStateResponseError{Code: pb.RpcAppSetDeviceStateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AppSetDeviceState(context.Background(), in).Marshal()
	return resp
}

func AppShutdown(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAppShutdownResponse{Error: &pb.RpcAppShutdownResponseError{Code: pb.RpcAppShutdownResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAppShutdownRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAppShutdownResponse{Error: &pb.RpcAppShutdownResponseError{Code: pb.RpcAppShutdownResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AppShutdown(context.Background(), in).Marshal()
	return resp
}

func WalletCreate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWalletCreateResponse{Error: &pb.RpcWalletCreateResponseError{Code: pb.RpcWalletCreateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWalletCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWalletCreateResponse{Error: &pb.RpcWalletCreateResponseError{Code: pb.RpcWalletCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WalletCreate(context.Background(), in).Marshal()
	return resp
}

func WalletRecover(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWalletRecoverResponse{Error: &pb.RpcWalletRecoverResponseError{Code: pb.RpcWalletRecoverResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWalletRecoverRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWalletRecoverResponse{Error: &pb.RpcWalletRecoverResponseError{Code: pb.RpcWalletRecoverResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WalletRecover(context.Background(), in).Marshal()
	return resp
}

func WalletConvert(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWalletConvertResponse{Error: &pb.RpcWalletConvertResponseError{Code: pb.RpcWalletConvertResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWalletConvertRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWalletConvertResponse{Error: &pb.RpcWalletConvertResponseError{Code: pb.RpcWalletConvertResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WalletConvert(context.Background(), in).Marshal()
	return resp
}

func AccountLocalLinkNewChallenge(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountLocalLinkNewChallengeResponse{Error: &pb.RpcAccountLocalLinkNewChallengeResponseError{Code: pb.RpcAccountLocalLinkNewChallengeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountLocalLinkNewChallengeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountLocalLinkNewChallengeResponse{Error: &pb.RpcAccountLocalLinkNewChallengeResponseError{Code: pb.RpcAccountLocalLinkNewChallengeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountLocalLinkNewChallenge(context.Background(), in).Marshal()
	return resp
}

func AccountLocalLinkSolveChallenge(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountLocalLinkSolveChallengeResponse{Error: &pb.RpcAccountLocalLinkSolveChallengeResponseError{Code: pb.RpcAccountLocalLinkSolveChallengeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountLocalLinkSolveChallengeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountLocalLinkSolveChallengeResponse{Error: &pb.RpcAccountLocalLinkSolveChallengeResponseError{Code: pb.RpcAccountLocalLinkSolveChallengeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountLocalLinkSolveChallenge(context.Background(), in).Marshal()
	return resp
}

func AccountLocalLinkCreateApp(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountLocalLinkCreateAppResponse{Error: &pb.RpcAccountLocalLinkCreateAppResponseError{Code: pb.RpcAccountLocalLinkCreateAppResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountLocalLinkCreateAppRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountLocalLinkCreateAppResponse{Error: &pb.RpcAccountLocalLinkCreateAppResponseError{Code: pb.RpcAccountLocalLinkCreateAppResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountLocalLinkCreateApp(context.Background(), in).Marshal()
	return resp
}

func AccountLocalLinkListApps(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountLocalLinkListAppsResponse{Error: &pb.RpcAccountLocalLinkListAppsResponseError{Code: pb.RpcAccountLocalLinkListAppsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountLocalLinkListAppsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountLocalLinkListAppsResponse{Error: &pb.RpcAccountLocalLinkListAppsResponseError{Code: pb.RpcAccountLocalLinkListAppsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountLocalLinkListApps(context.Background(), in).Marshal()
	return resp
}

func AccountLocalLinkRevokeApp(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountLocalLinkRevokeAppResponse{Error: &pb.RpcAccountLocalLinkRevokeAppResponseError{Code: pb.RpcAccountLocalLinkRevokeAppResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountLocalLinkRevokeAppRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountLocalLinkRevokeAppResponse{Error: &pb.RpcAccountLocalLinkRevokeAppResponseError{Code: pb.RpcAccountLocalLinkRevokeAppResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountLocalLinkRevokeApp(context.Background(), in).Marshal()
	return resp
}

func WalletCreateSession(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWalletCreateSessionResponse{Error: &pb.RpcWalletCreateSessionResponseError{Code: pb.RpcWalletCreateSessionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWalletCreateSessionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWalletCreateSessionResponse{Error: &pb.RpcWalletCreateSessionResponseError{Code: pb.RpcWalletCreateSessionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WalletCreateSession(context.Background(), in).Marshal()
	return resp
}

func WalletCloseSession(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWalletCloseSessionResponse{Error: &pb.RpcWalletCloseSessionResponseError{Code: pb.RpcWalletCloseSessionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWalletCloseSessionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWalletCloseSessionResponse{Error: &pb.RpcWalletCloseSessionResponseError{Code: pb.RpcWalletCloseSessionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WalletCloseSession(context.Background(), in).Marshal()
	return resp
}

func WorkspaceCreate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWorkspaceCreateResponse{Error: &pb.RpcWorkspaceCreateResponseError{Code: pb.RpcWorkspaceCreateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWorkspaceCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWorkspaceCreateResponse{Error: &pb.RpcWorkspaceCreateResponseError{Code: pb.RpcWorkspaceCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WorkspaceCreate(context.Background(), in).Marshal()
	return resp
}

func WorkspaceOpen(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWorkspaceOpenResponse{Error: &pb.RpcWorkspaceOpenResponseError{Code: pb.RpcWorkspaceOpenResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWorkspaceOpenRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWorkspaceOpenResponse{Error: &pb.RpcWorkspaceOpenResponseError{Code: pb.RpcWorkspaceOpenResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WorkspaceOpen(context.Background(), in).Marshal()
	return resp
}

func WorkspaceObjectAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWorkspaceObjectAddResponse{Error: &pb.RpcWorkspaceObjectAddResponseError{Code: pb.RpcWorkspaceObjectAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWorkspaceObjectAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWorkspaceObjectAddResponse{Error: &pb.RpcWorkspaceObjectAddResponseError{Code: pb.RpcWorkspaceObjectAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WorkspaceObjectAdd(context.Background(), in).Marshal()
	return resp
}

func WorkspaceObjectListAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWorkspaceObjectListAddResponse{Error: &pb.RpcWorkspaceObjectListAddResponseError{Code: pb.RpcWorkspaceObjectListAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWorkspaceObjectListAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWorkspaceObjectListAddResponse{Error: &pb.RpcWorkspaceObjectListAddResponseError{Code: pb.RpcWorkspaceObjectListAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WorkspaceObjectListAdd(context.Background(), in).Marshal()
	return resp
}

func WorkspaceObjectListRemove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWorkspaceObjectListRemoveResponse{Error: &pb.RpcWorkspaceObjectListRemoveResponseError{Code: pb.RpcWorkspaceObjectListRemoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWorkspaceObjectListRemoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWorkspaceObjectListRemoveResponse{Error: &pb.RpcWorkspaceObjectListRemoveResponseError{Code: pb.RpcWorkspaceObjectListRemoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WorkspaceObjectListRemove(context.Background(), in).Marshal()
	return resp
}

func WorkspaceSelect(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWorkspaceSelectResponse{Error: &pb.RpcWorkspaceSelectResponseError{Code: pb.RpcWorkspaceSelectResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWorkspaceSelectRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWorkspaceSelectResponse{Error: &pb.RpcWorkspaceSelectResponseError{Code: pb.RpcWorkspaceSelectResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WorkspaceSelect(context.Background(), in).Marshal()
	return resp
}

func WorkspaceGetCurrent(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWorkspaceGetCurrentResponse{Error: &pb.RpcWorkspaceGetCurrentResponseError{Code: pb.RpcWorkspaceGetCurrentResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWorkspaceGetCurrentRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWorkspaceGetCurrentResponse{Error: &pb.RpcWorkspaceGetCurrentResponseError{Code: pb.RpcWorkspaceGetCurrentResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WorkspaceGetCurrent(context.Background(), in).Marshal()
	return resp
}

func WorkspaceGetAll(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWorkspaceGetAllResponse{Error: &pb.RpcWorkspaceGetAllResponseError{Code: pb.RpcWorkspaceGetAllResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWorkspaceGetAllRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWorkspaceGetAllResponse{Error: &pb.RpcWorkspaceGetAllResponseError{Code: pb.RpcWorkspaceGetAllResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WorkspaceGetAll(context.Background(), in).Marshal()
	return resp
}

func WorkspaceSetInfo(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWorkspaceSetInfoResponse{Error: &pb.RpcWorkspaceSetInfoResponseError{Code: pb.RpcWorkspaceSetInfoResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWorkspaceSetInfoRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWorkspaceSetInfoResponse{Error: &pb.RpcWorkspaceSetInfoResponseError{Code: pb.RpcWorkspaceSetInfoResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WorkspaceSetInfo(context.Background(), in).Marshal()
	return resp
}

func WorkspaceExport(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcWorkspaceExportResponse{Error: &pb.RpcWorkspaceExportResponseError{Code: pb.RpcWorkspaceExportResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcWorkspaceExportRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcWorkspaceExportResponse{Error: &pb.RpcWorkspaceExportResponseError{Code: pb.RpcWorkspaceExportResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.WorkspaceExport(context.Background(), in).Marshal()
	return resp
}

func AccountRecover(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountRecoverResponse{Error: &pb.RpcAccountRecoverResponseError{Code: pb.RpcAccountRecoverResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountRecoverRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountRecoverResponse{Error: &pb.RpcAccountRecoverResponseError{Code: pb.RpcAccountRecoverResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountRecover(context.Background(), in).Marshal()
	return resp
}

func AccountMigrate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountMigrateResponse{Error: &pb.RpcAccountMigrateResponseError{Code: pb.RpcAccountMigrateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountMigrateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountMigrateResponse{Error: &pb.RpcAccountMigrateResponseError{Code: pb.RpcAccountMigrateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountMigrate(context.Background(), in).Marshal()
	return resp
}

func AccountMigrateCancel(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountMigrateCancelResponse{Error: &pb.RpcAccountMigrateCancelResponseError{Code: pb.RpcAccountMigrateCancelResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountMigrateCancelRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountMigrateCancelResponse{Error: &pb.RpcAccountMigrateCancelResponseError{Code: pb.RpcAccountMigrateCancelResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountMigrateCancel(context.Background(), in).Marshal()
	return resp
}

func AccountCreate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountCreateResponse{Error: &pb.RpcAccountCreateResponseError{Code: pb.RpcAccountCreateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountCreateResponse{Error: &pb.RpcAccountCreateResponseError{Code: pb.RpcAccountCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountCreate(context.Background(), in).Marshal()
	return resp
}

func AccountDelete(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountDeleteResponse{Error: &pb.RpcAccountDeleteResponseError{Code: pb.RpcAccountDeleteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountDeleteResponse{Error: &pb.RpcAccountDeleteResponseError{Code: pb.RpcAccountDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountDelete(context.Background(), in).Marshal()
	return resp
}

func AccountRevertDeletion(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountRevertDeletionResponse{Error: &pb.RpcAccountRevertDeletionResponseError{Code: pb.RpcAccountRevertDeletionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountRevertDeletionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountRevertDeletionResponse{Error: &pb.RpcAccountRevertDeletionResponseError{Code: pb.RpcAccountRevertDeletionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountRevertDeletion(context.Background(), in).Marshal()
	return resp
}

func AccountSelect(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountSelectResponse{Error: &pb.RpcAccountSelectResponseError{Code: pb.RpcAccountSelectResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountSelectRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountSelectResponse{Error: &pb.RpcAccountSelectResponseError{Code: pb.RpcAccountSelectResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountSelect(context.Background(), in).Marshal()
	return resp
}

func AccountEnableLocalNetworkSync(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountEnableLocalNetworkSyncResponse{Error: &pb.RpcAccountEnableLocalNetworkSyncResponseError{Code: pb.RpcAccountEnableLocalNetworkSyncResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountEnableLocalNetworkSyncRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountEnableLocalNetworkSyncResponse{Error: &pb.RpcAccountEnableLocalNetworkSyncResponseError{Code: pb.RpcAccountEnableLocalNetworkSyncResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountEnableLocalNetworkSync(context.Background(), in).Marshal()
	return resp
}

func AccountChangeJsonApiAddr(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountChangeJsonApiAddrResponse{Error: &pb.RpcAccountChangeJsonApiAddrResponseError{Code: pb.RpcAccountChangeJsonApiAddrResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountChangeJsonApiAddrRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountChangeJsonApiAddrResponse{Error: &pb.RpcAccountChangeJsonApiAddrResponseError{Code: pb.RpcAccountChangeJsonApiAddrResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountChangeJsonApiAddr(context.Background(), in).Marshal()
	return resp
}

func AccountStop(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountStopResponse{Error: &pb.RpcAccountStopResponseError{Code: pb.RpcAccountStopResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountStopRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountStopResponse{Error: &pb.RpcAccountStopResponseError{Code: pb.RpcAccountStopResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountStop(context.Background(), in).Marshal()
	return resp
}

func AccountMove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountMoveResponse{Error: &pb.RpcAccountMoveResponseError{Code: pb.RpcAccountMoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountMoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountMoveResponse{Error: &pb.RpcAccountMoveResponseError{Code: pb.RpcAccountMoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountMove(context.Background(), in).Marshal()
	return resp
}

func AccountConfigUpdate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountConfigUpdateResponse{Error: &pb.RpcAccountConfigUpdateResponseError{Code: pb.RpcAccountConfigUpdateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountConfigUpdateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountConfigUpdateResponse{Error: &pb.RpcAccountConfigUpdateResponseError{Code: pb.RpcAccountConfigUpdateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountConfigUpdate(context.Background(), in).Marshal()
	return resp
}

func AccountRecoverFromLegacyExport(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountRecoverFromLegacyExportResponse{Error: &pb.RpcAccountRecoverFromLegacyExportResponseError{Code: pb.RpcAccountRecoverFromLegacyExportResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountRecoverFromLegacyExportRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountRecoverFromLegacyExportResponse{Error: &pb.RpcAccountRecoverFromLegacyExportResponseError{Code: pb.RpcAccountRecoverFromLegacyExportResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountRecoverFromLegacyExport(context.Background(), in).Marshal()
	return resp
}

func AccountChangeNetworkConfigAndRestart(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAccountChangeNetworkConfigAndRestartResponse{Error: &pb.RpcAccountChangeNetworkConfigAndRestartResponseError{Code: pb.RpcAccountChangeNetworkConfigAndRestartResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAccountChangeNetworkConfigAndRestartRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAccountChangeNetworkConfigAndRestartResponse{Error: &pb.RpcAccountChangeNetworkConfigAndRestartResponseError{Code: pb.RpcAccountChangeNetworkConfigAndRestartResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AccountChangeNetworkConfigAndRestart(context.Background(), in).Marshal()
	return resp
}

func SpaceDelete(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceDeleteResponse{Error: &pb.RpcSpaceDeleteResponseError{Code: pb.RpcSpaceDeleteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceDeleteResponse{Error: &pb.RpcSpaceDeleteResponseError{Code: pb.RpcSpaceDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceDelete(context.Background(), in).Marshal()
	return resp
}

func SpaceInviteGenerate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceInviteGenerateResponse{Error: &pb.RpcSpaceInviteGenerateResponseError{Code: pb.RpcSpaceInviteGenerateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceInviteGenerateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceInviteGenerateResponse{Error: &pb.RpcSpaceInviteGenerateResponseError{Code: pb.RpcSpaceInviteGenerateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceInviteGenerate(context.Background(), in).Marshal()
	return resp
}

func SpaceInviteChange(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceInviteChangeResponse{Error: &pb.RpcSpaceInviteChangeResponseError{Code: pb.RpcSpaceInviteChangeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceInviteChangeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceInviteChangeResponse{Error: &pb.RpcSpaceInviteChangeResponseError{Code: pb.RpcSpaceInviteChangeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceInviteChange(context.Background(), in).Marshal()
	return resp
}

func SpaceInviteGetCurrent(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceInviteGetCurrentResponse{Error: &pb.RpcSpaceInviteGetCurrentResponseError{Code: pb.RpcSpaceInviteGetCurrentResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceInviteGetCurrentRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceInviteGetCurrentResponse{Error: &pb.RpcSpaceInviteGetCurrentResponseError{Code: pb.RpcSpaceInviteGetCurrentResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceInviteGetCurrent(context.Background(), in).Marshal()
	return resp
}

func SpaceInviteGetGuest(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceInviteGetGuestResponse{Error: &pb.RpcSpaceInviteGetGuestResponseError{Code: pb.RpcSpaceInviteGetGuestResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceInviteGetGuestRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceInviteGetGuestResponse{Error: &pb.RpcSpaceInviteGetGuestResponseError{Code: pb.RpcSpaceInviteGetGuestResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceInviteGetGuest(context.Background(), in).Marshal()
	return resp
}

func SpaceInviteRevoke(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceInviteRevokeResponse{Error: &pb.RpcSpaceInviteRevokeResponseError{Code: pb.RpcSpaceInviteRevokeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceInviteRevokeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceInviteRevokeResponse{Error: &pb.RpcSpaceInviteRevokeResponseError{Code: pb.RpcSpaceInviteRevokeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceInviteRevoke(context.Background(), in).Marshal()
	return resp
}

func SpaceInviteView(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceInviteViewResponse{Error: &pb.RpcSpaceInviteViewResponseError{Code: pb.RpcSpaceInviteViewResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceInviteViewRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceInviteViewResponse{Error: &pb.RpcSpaceInviteViewResponseError{Code: pb.RpcSpaceInviteViewResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceInviteView(context.Background(), in).Marshal()
	return resp
}

func SpaceJoin(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceJoinResponse{Error: &pb.RpcSpaceJoinResponseError{Code: pb.RpcSpaceJoinResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceJoinRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceJoinResponse{Error: &pb.RpcSpaceJoinResponseError{Code: pb.RpcSpaceJoinResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceJoin(context.Background(), in).Marshal()
	return resp
}

func SpaceJoinCancel(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceJoinCancelResponse{Error: &pb.RpcSpaceJoinCancelResponseError{Code: pb.RpcSpaceJoinCancelResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceJoinCancelRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceJoinCancelResponse{Error: &pb.RpcSpaceJoinCancelResponseError{Code: pb.RpcSpaceJoinCancelResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceJoinCancel(context.Background(), in).Marshal()
	return resp
}

func SpaceStopSharing(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceStopSharingResponse{Error: &pb.RpcSpaceStopSharingResponseError{Code: pb.RpcSpaceStopSharingResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceStopSharingRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceStopSharingResponse{Error: &pb.RpcSpaceStopSharingResponseError{Code: pb.RpcSpaceStopSharingResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceStopSharing(context.Background(), in).Marshal()
	return resp
}

func SpaceRequestApprove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceRequestApproveResponse{Error: &pb.RpcSpaceRequestApproveResponseError{Code: pb.RpcSpaceRequestApproveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceRequestApproveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceRequestApproveResponse{Error: &pb.RpcSpaceRequestApproveResponseError{Code: pb.RpcSpaceRequestApproveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceRequestApprove(context.Background(), in).Marshal()
	return resp
}

func SpaceRequestDecline(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceRequestDeclineResponse{Error: &pb.RpcSpaceRequestDeclineResponseError{Code: pb.RpcSpaceRequestDeclineResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceRequestDeclineRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceRequestDeclineResponse{Error: &pb.RpcSpaceRequestDeclineResponseError{Code: pb.RpcSpaceRequestDeclineResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceRequestDecline(context.Background(), in).Marshal()
	return resp
}

func SpaceLeaveApprove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceLeaveApproveResponse{Error: &pb.RpcSpaceLeaveApproveResponseError{Code: pb.RpcSpaceLeaveApproveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceLeaveApproveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceLeaveApproveResponse{Error: &pb.RpcSpaceLeaveApproveResponseError{Code: pb.RpcSpaceLeaveApproveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceLeaveApprove(context.Background(), in).Marshal()
	return resp
}

func SpaceMakeShareable(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceMakeShareableResponse{Error: &pb.RpcSpaceMakeShareableResponseError{Code: pb.RpcSpaceMakeShareableResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceMakeShareableRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceMakeShareableResponse{Error: &pb.RpcSpaceMakeShareableResponseError{Code: pb.RpcSpaceMakeShareableResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceMakeShareable(context.Background(), in).Marshal()
	return resp
}

func SpaceParticipantRemove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceParticipantRemoveResponse{Error: &pb.RpcSpaceParticipantRemoveResponseError{Code: pb.RpcSpaceParticipantRemoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceParticipantRemoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceParticipantRemoveResponse{Error: &pb.RpcSpaceParticipantRemoveResponseError{Code: pb.RpcSpaceParticipantRemoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceParticipantRemove(context.Background(), in).Marshal()
	return resp
}

func SpaceParticipantPermissionsChange(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceParticipantPermissionsChangeResponse{Error: &pb.RpcSpaceParticipantPermissionsChangeResponseError{Code: pb.RpcSpaceParticipantPermissionsChangeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceParticipantPermissionsChangeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceParticipantPermissionsChangeResponse{Error: &pb.RpcSpaceParticipantPermissionsChangeResponseError{Code: pb.RpcSpaceParticipantPermissionsChangeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceParticipantPermissionsChange(context.Background(), in).Marshal()
	return resp
}

func SpaceSetOrder(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceSetOrderResponse{Error: &pb.RpcSpaceSetOrderResponseError{Code: pb.RpcSpaceSetOrderResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceSetOrderRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceSetOrderResponse{Error: &pb.RpcSpaceSetOrderResponseError{Code: pb.RpcSpaceSetOrderResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceSetOrder(context.Background(), in).Marshal()
	return resp
}

func SpaceUnsetOrder(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcSpaceUnsetOrderResponse{Error: &pb.RpcSpaceUnsetOrderResponseError{Code: pb.RpcSpaceUnsetOrderResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcSpaceUnsetOrderRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSpaceUnsetOrderResponse{Error: &pb.RpcSpaceUnsetOrderResponseError{Code: pb.RpcSpaceUnsetOrderResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SpaceUnsetOrder(context.Background(), in).Marshal()
	return resp
}

func PublishingCreate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcPublishingCreateResponse{Error: &pb.RpcPublishingCreateResponseError{Code: pb.RpcPublishingCreateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcPublishingCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcPublishingCreateResponse{Error: &pb.RpcPublishingCreateResponseError{Code: pb.RpcPublishingCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.PublishingCreate(context.Background(), in).Marshal()
	return resp
}

func PublishingRemove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcPublishingRemoveResponse{Error: &pb.RpcPublishingRemoveResponseError{Code: pb.RpcPublishingRemoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcPublishingRemoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcPublishingRemoveResponse{Error: &pb.RpcPublishingRemoveResponseError{Code: pb.RpcPublishingRemoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.PublishingRemove(context.Background(), in).Marshal()
	return resp
}

func PublishingList(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcPublishingListResponse{Error: &pb.RpcPublishingListResponseError{Code: pb.RpcPublishingListResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcPublishingListRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcPublishingListResponse{Error: &pb.RpcPublishingListResponseError{Code: pb.RpcPublishingListResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.PublishingList(context.Background(), in).Marshal()
	return resp
}

func PublishingResolveUri(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcPublishingResolveUriResponse{Error: &pb.RpcPublishingResolveUriResponseError{Code: pb.RpcPublishingResolveUriResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcPublishingResolveUriRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcPublishingResolveUriResponse{Error: &pb.RpcPublishingResolveUriResponseError{Code: pb.RpcPublishingResolveUriResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.PublishingResolveUri(context.Background(), in).Marshal()
	return resp
}

func PublishingGetStatus(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcPublishingGetStatusResponse{Error: &pb.RpcPublishingGetStatusResponseError{Code: pb.RpcPublishingGetStatusResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcPublishingGetStatusRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcPublishingGetStatusResponse{Error: &pb.RpcPublishingGetStatusResponseError{Code: pb.RpcPublishingGetStatusResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.PublishingGetStatus(context.Background(), in).Marshal()
	return resp
}

func ObjectOpen(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectOpenResponse{Error: &pb.RpcObjectOpenResponseError{Code: pb.RpcObjectOpenResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectOpenRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectOpenResponse{Error: &pb.RpcObjectOpenResponseError{Code: pb.RpcObjectOpenResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectOpen(context.Background(), in).Marshal()
	return resp
}

func ObjectRefresh(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectRefreshResponse{Error: &pb.RpcObjectRefreshResponseError{Code: pb.RpcObjectRefreshResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectRefreshRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRefreshResponse{Error: &pb.RpcObjectRefreshResponseError{Code: pb.RpcObjectRefreshResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRefresh(context.Background(), in).Marshal()
	return resp
}

func ObjectClose(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCloseResponse{Error: &pb.RpcObjectCloseResponseError{Code: pb.RpcObjectCloseResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCloseRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCloseResponse{Error: &pb.RpcObjectCloseResponseError{Code: pb.RpcObjectCloseResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectClose(context.Background(), in).Marshal()
	return resp
}

func ObjectShow(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectShowResponse{Error: &pb.RpcObjectShowResponseError{Code: pb.RpcObjectShowResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectShowRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectShowResponse{Error: &pb.RpcObjectShowResponseError{Code: pb.RpcObjectShowResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectShow(context.Background(), in).Marshal()
	return resp
}

func ObjectCreate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCreateResponse{Error: &pb.RpcObjectCreateResponseError{Code: pb.RpcObjectCreateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCreateResponse{Error: &pb.RpcObjectCreateResponseError{Code: pb.RpcObjectCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCreate(context.Background(), in).Marshal()
	return resp
}

func ObjectCreateBookmark(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCreateBookmarkResponse{Error: &pb.RpcObjectCreateBookmarkResponseError{Code: pb.RpcObjectCreateBookmarkResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCreateBookmarkRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCreateBookmarkResponse{Error: &pb.RpcObjectCreateBookmarkResponseError{Code: pb.RpcObjectCreateBookmarkResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCreateBookmark(context.Background(), in).Marshal()
	return resp
}

func ObjectCreateFromUrl(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCreateFromUrlResponse{Error: &pb.RpcObjectCreateFromUrlResponseError{Code: pb.RpcObjectCreateFromUrlResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCreateFromUrlRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCreateFromUrlResponse{Error: &pb.RpcObjectCreateFromUrlResponseError{Code: pb.RpcObjectCreateFromUrlResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCreateFromUrl(context.Background(), in).Marshal()
	return resp
}

func ObjectCreateSet(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCreateSetResponse{Error: &pb.RpcObjectCreateSetResponseError{Code: pb.RpcObjectCreateSetResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCreateSetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCreateSetResponse{Error: &pb.RpcObjectCreateSetResponseError{Code: pb.RpcObjectCreateSetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCreateSet(context.Background(), in).Marshal()
	return resp
}

func ObjectGraph(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectGraphResponse{Error: &pb.RpcObjectGraphResponseError{Code: pb.RpcObjectGraphResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectGraphRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectGraphResponse{Error: &pb.RpcObjectGraphResponseError{Code: pb.RpcObjectGraphResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectGraph(context.Background(), in).Marshal()
	return resp
}

func ObjectSearch(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSearchResponse{Error: &pb.RpcObjectSearchResponseError{Code: pb.RpcObjectSearchResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSearchRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSearchResponse{Error: &pb.RpcObjectSearchResponseError{Code: pb.RpcObjectSearchResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSearch(context.Background(), in).Marshal()
	return resp
}

func ObjectSearchWithMeta(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSearchWithMetaResponse{Error: &pb.RpcObjectSearchWithMetaResponseError{Code: pb.RpcObjectSearchWithMetaResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSearchWithMetaRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSearchWithMetaResponse{Error: &pb.RpcObjectSearchWithMetaResponseError{Code: pb.RpcObjectSearchWithMetaResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSearchWithMeta(context.Background(), in).Marshal()
	return resp
}

func ObjectSearchSubscribe(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSearchSubscribeResponse{Error: &pb.RpcObjectSearchSubscribeResponseError{Code: pb.RpcObjectSearchSubscribeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSearchSubscribeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSearchSubscribeResponse{Error: &pb.RpcObjectSearchSubscribeResponseError{Code: pb.RpcObjectSearchSubscribeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSearchSubscribe(context.Background(), in).Marshal()
	return resp
}

func ObjectCrossSpaceSearchSubscribe(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCrossSpaceSearchSubscribeResponse{Error: &pb.RpcObjectCrossSpaceSearchSubscribeResponseError{Code: pb.RpcObjectCrossSpaceSearchSubscribeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCrossSpaceSearchSubscribeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCrossSpaceSearchSubscribeResponse{Error: &pb.RpcObjectCrossSpaceSearchSubscribeResponseError{Code: pb.RpcObjectCrossSpaceSearchSubscribeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCrossSpaceSearchSubscribe(context.Background(), in).Marshal()
	return resp
}

func ObjectCrossSpaceSearchUnsubscribe(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCrossSpaceSearchUnsubscribeResponse{Error: &pb.RpcObjectCrossSpaceSearchUnsubscribeResponseError{Code: pb.RpcObjectCrossSpaceSearchUnsubscribeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCrossSpaceSearchUnsubscribeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCrossSpaceSearchUnsubscribeResponse{Error: &pb.RpcObjectCrossSpaceSearchUnsubscribeResponseError{Code: pb.RpcObjectCrossSpaceSearchUnsubscribeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCrossSpaceSearchUnsubscribe(context.Background(), in).Marshal()
	return resp
}

func ObjectSubscribeIds(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSubscribeIdsResponse{Error: &pb.RpcObjectSubscribeIdsResponseError{Code: pb.RpcObjectSubscribeIdsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSubscribeIdsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSubscribeIdsResponse{Error: &pb.RpcObjectSubscribeIdsResponseError{Code: pb.RpcObjectSubscribeIdsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSubscribeIds(context.Background(), in).Marshal()
	return resp
}

func ObjectGroupsSubscribe(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectGroupsSubscribeResponse{Error: &pb.RpcObjectGroupsSubscribeResponseError{Code: pb.RpcObjectGroupsSubscribeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectGroupsSubscribeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectGroupsSubscribeResponse{Error: &pb.RpcObjectGroupsSubscribeResponseError{Code: pb.RpcObjectGroupsSubscribeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectGroupsSubscribe(context.Background(), in).Marshal()
	return resp
}

func ObjectSearchUnsubscribe(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSearchUnsubscribeResponse{Error: &pb.RpcObjectSearchUnsubscribeResponseError{Code: pb.RpcObjectSearchUnsubscribeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSearchUnsubscribeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSearchUnsubscribeResponse{Error: &pb.RpcObjectSearchUnsubscribeResponseError{Code: pb.RpcObjectSearchUnsubscribeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSearchUnsubscribe(context.Background(), in).Marshal()
	return resp
}

func ObjectSetDetails(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSetDetailsResponse{Error: &pb.RpcObjectSetDetailsResponseError{Code: pb.RpcObjectSetDetailsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSetDetailsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSetDetailsResponse{Error: &pb.RpcObjectSetDetailsResponseError{Code: pb.RpcObjectSetDetailsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSetDetails(context.Background(), in).Marshal()
	return resp
}

func ObjectDuplicate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectDuplicateResponse{Error: &pb.RpcObjectDuplicateResponseError{Code: pb.RpcObjectDuplicateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectDuplicateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectDuplicateResponse{Error: &pb.RpcObjectDuplicateResponseError{Code: pb.RpcObjectDuplicateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectDuplicate(context.Background(), in).Marshal()
	return resp
}

func ObjectSetObjectType(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSetObjectTypeResponse{Error: &pb.RpcObjectSetObjectTypeResponseError{Code: pb.RpcObjectSetObjectTypeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSetObjectTypeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSetObjectTypeResponse{Error: &pb.RpcObjectSetObjectTypeResponseError{Code: pb.RpcObjectSetObjectTypeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSetObjectType(context.Background(), in).Marshal()
	return resp
}

func ObjectSetLayout(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSetLayoutResponse{Error: &pb.RpcObjectSetLayoutResponseError{Code: pb.RpcObjectSetLayoutResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSetLayoutRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSetLayoutResponse{Error: &pb.RpcObjectSetLayoutResponseError{Code: pb.RpcObjectSetLayoutResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSetLayout(context.Background(), in).Marshal()
	return resp
}

func ObjectSetInternalFlags(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSetInternalFlagsResponse{Error: &pb.RpcObjectSetInternalFlagsResponseError{Code: pb.RpcObjectSetInternalFlagsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSetInternalFlagsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSetInternalFlagsResponse{Error: &pb.RpcObjectSetInternalFlagsResponseError{Code: pb.RpcObjectSetInternalFlagsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSetInternalFlags(context.Background(), in).Marshal()
	return resp
}

func ObjectSetIsFavorite(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSetIsFavoriteResponse{Error: &pb.RpcObjectSetIsFavoriteResponseError{Code: pb.RpcObjectSetIsFavoriteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSetIsFavoriteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSetIsFavoriteResponse{Error: &pb.RpcObjectSetIsFavoriteResponseError{Code: pb.RpcObjectSetIsFavoriteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSetIsFavorite(context.Background(), in).Marshal()
	return resp
}

func ObjectSetIsArchived(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSetIsArchivedResponse{Error: &pb.RpcObjectSetIsArchivedResponseError{Code: pb.RpcObjectSetIsArchivedResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSetIsArchivedRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSetIsArchivedResponse{Error: &pb.RpcObjectSetIsArchivedResponseError{Code: pb.RpcObjectSetIsArchivedResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSetIsArchived(context.Background(), in).Marshal()
	return resp
}

func ObjectSetSource(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectSetSourceResponse{Error: &pb.RpcObjectSetSourceResponseError{Code: pb.RpcObjectSetSourceResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectSetSourceRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectSetSourceResponse{Error: &pb.RpcObjectSetSourceResponseError{Code: pb.RpcObjectSetSourceResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectSetSource(context.Background(), in).Marshal()
	return resp
}

func ObjectWorkspaceSetDashboard(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectWorkspaceSetDashboardResponse{Error: &pb.RpcObjectWorkspaceSetDashboardResponseError{Code: pb.RpcObjectWorkspaceSetDashboardResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectWorkspaceSetDashboardRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectWorkspaceSetDashboardResponse{Error: &pb.RpcObjectWorkspaceSetDashboardResponseError{Code: pb.RpcObjectWorkspaceSetDashboardResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectWorkspaceSetDashboard(context.Background(), in).Marshal()
	return resp
}

func ObjectListDuplicate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectListDuplicateResponse{Error: &pb.RpcObjectListDuplicateResponseError{Code: pb.RpcObjectListDuplicateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectListDuplicateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectListDuplicateResponse{Error: &pb.RpcObjectListDuplicateResponseError{Code: pb.RpcObjectListDuplicateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectListDuplicate(context.Background(), in).Marshal()
	return resp
}

func ObjectListDelete(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectListDeleteResponse{Error: &pb.RpcObjectListDeleteResponseError{Code: pb.RpcObjectListDeleteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectListDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectListDeleteResponse{Error: &pb.RpcObjectListDeleteResponseError{Code: pb.RpcObjectListDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectListDelete(context.Background(), in).Marshal()
	return resp
}

func ObjectListSetIsArchived(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectListSetIsArchivedResponse{Error: &pb.RpcObjectListSetIsArchivedResponseError{Code: pb.RpcObjectListSetIsArchivedResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectListSetIsArchivedRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectListSetIsArchivedResponse{Error: &pb.RpcObjectListSetIsArchivedResponseError{Code: pb.RpcObjectListSetIsArchivedResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectListSetIsArchived(context.Background(), in).Marshal()
	return resp
}

func ObjectListSetIsFavorite(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectListSetIsFavoriteResponse{Error: &pb.RpcObjectListSetIsFavoriteResponseError{Code: pb.RpcObjectListSetIsFavoriteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectListSetIsFavoriteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectListSetIsFavoriteResponse{Error: &pb.RpcObjectListSetIsFavoriteResponseError{Code: pb.RpcObjectListSetIsFavoriteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectListSetIsFavorite(context.Background(), in).Marshal()
	return resp
}

func ObjectListSetObjectType(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectListSetObjectTypeResponse{Error: &pb.RpcObjectListSetObjectTypeResponseError{Code: pb.RpcObjectListSetObjectTypeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectListSetObjectTypeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectListSetObjectTypeResponse{Error: &pb.RpcObjectListSetObjectTypeResponseError{Code: pb.RpcObjectListSetObjectTypeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectListSetObjectType(context.Background(), in).Marshal()
	return resp
}

func ObjectListSetDetails(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectListSetDetailsResponse{Error: &pb.RpcObjectListSetDetailsResponseError{Code: pb.RpcObjectListSetDetailsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectListSetDetailsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectListSetDetailsResponse{Error: &pb.RpcObjectListSetDetailsResponseError{Code: pb.RpcObjectListSetDetailsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectListSetDetails(context.Background(), in).Marshal()
	return resp
}

func ObjectListModifyDetailValues(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectListModifyDetailValuesResponse{Error: &pb.RpcObjectListModifyDetailValuesResponseError{Code: pb.RpcObjectListModifyDetailValuesResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectListModifyDetailValuesRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectListModifyDetailValuesResponse{Error: &pb.RpcObjectListModifyDetailValuesResponseError{Code: pb.RpcObjectListModifyDetailValuesResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectListModifyDetailValues(context.Background(), in).Marshal()
	return resp
}

func ObjectApplyTemplate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectApplyTemplateResponse{Error: &pb.RpcObjectApplyTemplateResponseError{Code: pb.RpcObjectApplyTemplateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectApplyTemplateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectApplyTemplateResponse{Error: &pb.RpcObjectApplyTemplateResponseError{Code: pb.RpcObjectApplyTemplateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectApplyTemplate(context.Background(), in).Marshal()
	return resp
}

func ObjectToSet(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectToSetResponse{Error: &pb.RpcObjectToSetResponseError{Code: pb.RpcObjectToSetResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectToSetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectToSetResponse{Error: &pb.RpcObjectToSetResponseError{Code: pb.RpcObjectToSetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectToSet(context.Background(), in).Marshal()
	return resp
}

func ObjectToCollection(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectToCollectionResponse{Error: &pb.RpcObjectToCollectionResponseError{Code: pb.RpcObjectToCollectionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectToCollectionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectToCollectionResponse{Error: &pb.RpcObjectToCollectionResponseError{Code: pb.RpcObjectToCollectionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectToCollection(context.Background(), in).Marshal()
	return resp
}

func ObjectShareByLink(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectShareByLinkResponse{Error: &pb.RpcObjectShareByLinkResponseError{Code: pb.RpcObjectShareByLinkResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectShareByLinkRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectShareByLinkResponse{Error: &pb.RpcObjectShareByLinkResponseError{Code: pb.RpcObjectShareByLinkResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectShareByLink(context.Background(), in).Marshal()
	return resp
}

func ObjectUndo(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectUndoResponse{Error: &pb.RpcObjectUndoResponseError{Code: pb.RpcObjectUndoResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectUndoRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectUndoResponse{Error: &pb.RpcObjectUndoResponseError{Code: pb.RpcObjectUndoResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectUndo(context.Background(), in).Marshal()
	return resp
}

func ObjectRedo(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectRedoResponse{Error: &pb.RpcObjectRedoResponseError{Code: pb.RpcObjectRedoResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectRedoRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRedoResponse{Error: &pb.RpcObjectRedoResponseError{Code: pb.RpcObjectRedoResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRedo(context.Background(), in).Marshal()
	return resp
}

func ObjectListExport(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectListExportResponse{Error: &pb.RpcObjectListExportResponseError{Code: pb.RpcObjectListExportResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectListExportRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectListExportResponse{Error: &pb.RpcObjectListExportResponseError{Code: pb.RpcObjectListExportResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectListExport(context.Background(), in).Marshal()
	return resp
}

func ObjectExport(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectExportResponse{Error: &pb.RpcObjectExportResponseError{Code: pb.RpcObjectExportResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectExportRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectExportResponse{Error: &pb.RpcObjectExportResponseError{Code: pb.RpcObjectExportResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectExport(context.Background(), in).Marshal()
	return resp
}

func ObjectBookmarkFetch(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectBookmarkFetchResponse{Error: &pb.RpcObjectBookmarkFetchResponseError{Code: pb.RpcObjectBookmarkFetchResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectBookmarkFetchRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectBookmarkFetchResponse{Error: &pb.RpcObjectBookmarkFetchResponseError{Code: pb.RpcObjectBookmarkFetchResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectBookmarkFetch(context.Background(), in).Marshal()
	return resp
}

func ObjectImport(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectImportResponse{Error: &pb.RpcObjectImportResponseError{Code: pb.RpcObjectImportResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectImportRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectImportResponse{Error: &pb.RpcObjectImportResponseError{Code: pb.RpcObjectImportResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectImport(context.Background(), in).Marshal()
	return resp
}

func ObjectImportList(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectImportListResponse{Error: &pb.RpcObjectImportListResponseError{Code: pb.RpcObjectImportListResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectImportListRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectImportListResponse{Error: &pb.RpcObjectImportListResponseError{Code: pb.RpcObjectImportListResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectImportList(context.Background(), in).Marshal()
	return resp
}

func ObjectImportNotionValidateToken(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectImportNotionValidateTokenResponse{Error: &pb.RpcObjectImportNotionValidateTokenResponseError{Code: pb.RpcObjectImportNotionValidateTokenResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectImportNotionValidateTokenRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectImportNotionValidateTokenResponse{Error: &pb.RpcObjectImportNotionValidateTokenResponseError{Code: pb.RpcObjectImportNotionValidateTokenResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectImportNotionValidateToken(context.Background(), in).Marshal()
	return resp
}

func ObjectImportUseCase(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectImportUseCaseResponse{Error: &pb.RpcObjectImportUseCaseResponseError{Code: pb.RpcObjectImportUseCaseResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectImportUseCaseRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectImportUseCaseResponse{Error: &pb.RpcObjectImportUseCaseResponseError{Code: pb.RpcObjectImportUseCaseResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectImportUseCase(context.Background(), in).Marshal()
	return resp
}

func ObjectImportExperience(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectImportExperienceResponse{Error: &pb.RpcObjectImportExperienceResponseError{Code: pb.RpcObjectImportExperienceResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectImportExperienceRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectImportExperienceResponse{Error: &pb.RpcObjectImportExperienceResponseError{Code: pb.RpcObjectImportExperienceResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectImportExperience(context.Background(), in).Marshal()
	return resp
}

func ObjectDateByTimestamp(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectDateByTimestampResponse{Error: &pb.RpcObjectDateByTimestampResponseError{Code: pb.RpcObjectDateByTimestampResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectDateByTimestampRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectDateByTimestampResponse{Error: &pb.RpcObjectDateByTimestampResponseError{Code: pb.RpcObjectDateByTimestampResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectDateByTimestamp(context.Background(), in).Marshal()
	return resp
}

func ObjectCollectionAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCollectionAddResponse{Error: &pb.RpcObjectCollectionAddResponseError{Code: pb.RpcObjectCollectionAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCollectionAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCollectionAddResponse{Error: &pb.RpcObjectCollectionAddResponseError{Code: pb.RpcObjectCollectionAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCollectionAdd(context.Background(), in).Marshal()
	return resp
}

func ObjectCollectionRemove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCollectionRemoveResponse{Error: &pb.RpcObjectCollectionRemoveResponseError{Code: pb.RpcObjectCollectionRemoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCollectionRemoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCollectionRemoveResponse{Error: &pb.RpcObjectCollectionRemoveResponseError{Code: pb.RpcObjectCollectionRemoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCollectionRemove(context.Background(), in).Marshal()
	return resp
}

func ObjectCollectionSort(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCollectionSortResponse{Error: &pb.RpcObjectCollectionSortResponseError{Code: pb.RpcObjectCollectionSortResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCollectionSortRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCollectionSortResponse{Error: &pb.RpcObjectCollectionSortResponseError{Code: pb.RpcObjectCollectionSortResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCollectionSort(context.Background(), in).Marshal()
	return resp
}

func ObjectCreateRelation(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCreateRelationResponse{Error: &pb.RpcObjectCreateRelationResponseError{Code: pb.RpcObjectCreateRelationResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCreateRelationRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCreateRelationResponse{Error: &pb.RpcObjectCreateRelationResponseError{Code: pb.RpcObjectCreateRelationResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCreateRelation(context.Background(), in).Marshal()
	return resp
}

func ObjectCreateRelationOption(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCreateRelationOptionResponse{Error: &pb.RpcObjectCreateRelationOptionResponseError{Code: pb.RpcObjectCreateRelationOptionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCreateRelationOptionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCreateRelationOptionResponse{Error: &pb.RpcObjectCreateRelationOptionResponseError{Code: pb.RpcObjectCreateRelationOptionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCreateRelationOption(context.Background(), in).Marshal()
	return resp
}

func RelationListRemoveOption(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcRelationListRemoveOptionResponse{Error: &pb.RpcRelationListRemoveOptionResponseError{Code: pb.RpcRelationListRemoveOptionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcRelationListRemoveOptionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcRelationListRemoveOptionResponse{Error: &pb.RpcRelationListRemoveOptionResponseError{Code: pb.RpcRelationListRemoveOptionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.RelationListRemoveOption(context.Background(), in).Marshal()
	return resp
}

func RelationOptions(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcRelationOptionsResponse{Error: &pb.RpcRelationOptionsResponseError{Code: pb.RpcRelationOptionsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcRelationOptionsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcRelationOptionsResponse{Error: &pb.RpcRelationOptionsResponseError{Code: pb.RpcRelationOptionsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.RelationOptions(context.Background(), in).Marshal()
	return resp
}

func RelationOptionSetOrder(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcRelationOptionSetOrderResponse{Error: &pb.RpcRelationOptionSetOrderResponseError{Code: pb.RpcRelationOptionSetOrderResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcRelationOptionSetOrderRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcRelationOptionSetOrderResponse{Error: &pb.RpcRelationOptionSetOrderResponseError{Code: pb.RpcRelationOptionSetOrderResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.RelationOptionSetOrder(context.Background(), in).Marshal()
	return resp
}

func RelationListWithValue(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcRelationListWithValueResponse{Error: &pb.RpcRelationListWithValueResponseError{Code: pb.RpcRelationListWithValueResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcRelationListWithValueRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcRelationListWithValueResponse{Error: &pb.RpcRelationListWithValueResponseError{Code: pb.RpcRelationListWithValueResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.RelationListWithValue(context.Background(), in).Marshal()
	return resp
}

func ObjectRelationAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectRelationAddResponse{Error: &pb.RpcObjectRelationAddResponseError{Code: pb.RpcObjectRelationAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectRelationAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRelationAddResponse{Error: &pb.RpcObjectRelationAddResponseError{Code: pb.RpcObjectRelationAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRelationAdd(context.Background(), in).Marshal()
	return resp
}

func ObjectRelationDelete(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectRelationDeleteResponse{Error: &pb.RpcObjectRelationDeleteResponseError{Code: pb.RpcObjectRelationDeleteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectRelationDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRelationDeleteResponse{Error: &pb.RpcObjectRelationDeleteResponseError{Code: pb.RpcObjectRelationDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRelationDelete(context.Background(), in).Marshal()
	return resp
}

func ObjectRelationAddFeatured(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectRelationAddFeaturedResponse{Error: &pb.RpcObjectRelationAddFeaturedResponseError{Code: pb.RpcObjectRelationAddFeaturedResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectRelationAddFeaturedRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRelationAddFeaturedResponse{Error: &pb.RpcObjectRelationAddFeaturedResponseError{Code: pb.RpcObjectRelationAddFeaturedResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRelationAddFeatured(context.Background(), in).Marshal()
	return resp
}

func ObjectRelationRemoveFeatured(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectRelationRemoveFeaturedResponse{Error: &pb.RpcObjectRelationRemoveFeaturedResponseError{Code: pb.RpcObjectRelationRemoveFeaturedResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectRelationRemoveFeaturedRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRelationRemoveFeaturedResponse{Error: &pb.RpcObjectRelationRemoveFeaturedResponseError{Code: pb.RpcObjectRelationRemoveFeaturedResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRelationRemoveFeatured(context.Background(), in).Marshal()
	return resp
}

func ObjectRelationListAvailable(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectRelationListAvailableResponse{Error: &pb.RpcObjectRelationListAvailableResponseError{Code: pb.RpcObjectRelationListAvailableResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectRelationListAvailableRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRelationListAvailableResponse{Error: &pb.RpcObjectRelationListAvailableResponseError{Code: pb.RpcObjectRelationListAvailableResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRelationListAvailable(context.Background(), in).Marshal()
	return resp
}

func ObjectCreateObjectType(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectCreateObjectTypeResponse{Error: &pb.RpcObjectCreateObjectTypeResponseError{Code: pb.RpcObjectCreateObjectTypeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectCreateObjectTypeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectCreateObjectTypeResponse{Error: &pb.RpcObjectCreateObjectTypeResponseError{Code: pb.RpcObjectCreateObjectTypeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectCreateObjectType(context.Background(), in).Marshal()
	return resp
}

func ObjectTypeRelationAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectTypeRelationAddResponse{Error: &pb.RpcObjectTypeRelationAddResponseError{Code: pb.RpcObjectTypeRelationAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectTypeRelationAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeRelationAddResponse{Error: &pb.RpcObjectTypeRelationAddResponseError{Code: pb.RpcObjectTypeRelationAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeRelationAdd(context.Background(), in).Marshal()
	return resp
}

func ObjectTypeRelationRemove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectTypeRelationRemoveResponse{Error: &pb.RpcObjectTypeRelationRemoveResponseError{Code: pb.RpcObjectTypeRelationRemoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectTypeRelationRemoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeRelationRemoveResponse{Error: &pb.RpcObjectTypeRelationRemoveResponseError{Code: pb.RpcObjectTypeRelationRemoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeRelationRemove(context.Background(), in).Marshal()
	return resp
}

func ObjectTypeRecommendedRelationsSet(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectTypeRecommendedRelationsSetResponse{Error: &pb.RpcObjectTypeRecommendedRelationsSetResponseError{Code: pb.RpcObjectTypeRecommendedRelationsSetResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectTypeRecommendedRelationsSetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeRecommendedRelationsSetResponse{Error: &pb.RpcObjectTypeRecommendedRelationsSetResponseError{Code: pb.RpcObjectTypeRecommendedRelationsSetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeRecommendedRelationsSet(context.Background(), in).Marshal()
	return resp
}

func ObjectTypeRecommendedFeaturedRelationsSet(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectTypeRecommendedFeaturedRelationsSetResponse{Error: &pb.RpcObjectTypeRecommendedFeaturedRelationsSetResponseError{Code: pb.RpcObjectTypeRecommendedFeaturedRelationsSetResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectTypeRecommendedFeaturedRelationsSetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeRecommendedFeaturedRelationsSetResponse{Error: &pb.RpcObjectTypeRecommendedFeaturedRelationsSetResponseError{Code: pb.RpcObjectTypeRecommendedFeaturedRelationsSetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeRecommendedFeaturedRelationsSet(context.Background(), in).Marshal()
	return resp
}

func ObjectTypeListConflictingRelations(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectTypeListConflictingRelationsResponse{Error: &pb.RpcObjectTypeListConflictingRelationsResponseError{Code: pb.RpcObjectTypeListConflictingRelationsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectTypeListConflictingRelationsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeListConflictingRelationsResponse{Error: &pb.RpcObjectTypeListConflictingRelationsResponseError{Code: pb.RpcObjectTypeListConflictingRelationsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeListConflictingRelations(context.Background(), in).Marshal()
	return resp
}

func ObjectTypeResolveLayoutConflicts(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectTypeResolveLayoutConflictsResponse{Error: &pb.RpcObjectTypeResolveLayoutConflictsResponseError{Code: pb.RpcObjectTypeResolveLayoutConflictsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectTypeResolveLayoutConflictsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeResolveLayoutConflictsResponse{Error: &pb.RpcObjectTypeResolveLayoutConflictsResponseError{Code: pb.RpcObjectTypeResolveLayoutConflictsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeResolveLayoutConflicts(context.Background(), in).Marshal()
	return resp
}

func ObjectTypeSetOrder(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectTypeSetOrderResponse{Error: &pb.RpcObjectTypeSetOrderResponseError{Code: pb.RpcObjectTypeSetOrderResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectTypeSetOrderRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeSetOrderResponse{Error: &pb.RpcObjectTypeSetOrderResponseError{Code: pb.RpcObjectTypeSetOrderResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeSetOrder(context.Background(), in).Marshal()
	return resp
}

func HistoryShowVersion(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcHistoryShowVersionResponse{Error: &pb.RpcHistoryShowVersionResponseError{Code: pb.RpcHistoryShowVersionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcHistoryShowVersionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcHistoryShowVersionResponse{Error: &pb.RpcHistoryShowVersionResponseError{Code: pb.RpcHistoryShowVersionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.HistoryShowVersion(context.Background(), in).Marshal()
	return resp
}

func HistoryGetVersions(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcHistoryGetVersionsResponse{Error: &pb.RpcHistoryGetVersionsResponseError{Code: pb.RpcHistoryGetVersionsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcHistoryGetVersionsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcHistoryGetVersionsResponse{Error: &pb.RpcHistoryGetVersionsResponseError{Code: pb.RpcHistoryGetVersionsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.HistoryGetVersions(context.Background(), in).Marshal()
	return resp
}

func HistorySetVersion(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcHistorySetVersionResponse{Error: &pb.RpcHistorySetVersionResponseError{Code: pb.RpcHistorySetVersionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcHistorySetVersionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcHistorySetVersionResponse{Error: &pb.RpcHistorySetVersionResponseError{Code: pb.RpcHistorySetVersionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.HistorySetVersion(context.Background(), in).Marshal()
	return resp
}

func HistoryDiffVersions(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcHistoryDiffVersionsResponse{Error: &pb.RpcHistoryDiffVersionsResponseError{Code: pb.RpcHistoryDiffVersionsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcHistoryDiffVersionsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcHistoryDiffVersionsResponse{Error: &pb.RpcHistoryDiffVersionsResponseError{Code: pb.RpcHistoryDiffVersionsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.HistoryDiffVersions(context.Background(), in).Marshal()
	return resp
}

func FileSpaceOffload(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcFileSpaceOffloadResponse{Error: &pb.RpcFileSpaceOffloadResponseError{Code: pb.RpcFileSpaceOffloadResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcFileSpaceOffloadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcFileSpaceOffloadResponse{Error: &pb.RpcFileSpaceOffloadResponseError{Code: pb.RpcFileSpaceOffloadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.FileSpaceOffload(context.Background(), in).Marshal()
	return resp
}

func FileReconcile(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcFileReconcileResponse{Error: &pb.RpcFileReconcileResponseError{Code: pb.RpcFileReconcileResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcFileReconcileRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcFileReconcileResponse{Error: &pb.RpcFileReconcileResponseError{Code: pb.RpcFileReconcileResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.FileReconcile(context.Background(), in).Marshal()
	return resp
}

func FileListOffload(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcFileListOffloadResponse{Error: &pb.RpcFileListOffloadResponseError{Code: pb.RpcFileListOffloadResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcFileListOffloadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcFileListOffloadResponse{Error: &pb.RpcFileListOffloadResponseError{Code: pb.RpcFileListOffloadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.FileListOffload(context.Background(), in).Marshal()
	return resp
}

func FileUpload(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcFileUploadResponse{Error: &pb.RpcFileUploadResponseError{Code: pb.RpcFileUploadResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcFileUploadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcFileUploadResponse{Error: &pb.RpcFileUploadResponseError{Code: pb.RpcFileUploadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.FileUpload(context.Background(), in).Marshal()
	return resp
}

func FileDownload(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcFileDownloadResponse{Error: &pb.RpcFileDownloadResponseError{Code: pb.RpcFileDownloadResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcFileDownloadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcFileDownloadResponse{Error: &pb.RpcFileDownloadResponseError{Code: pb.RpcFileDownloadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.FileDownload(context.Background(), in).Marshal()
	return resp
}

func FileDiscardPreload(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcFileDiscardPreloadResponse{Error: &pb.RpcFileDiscardPreloadResponseError{Code: pb.RpcFileDiscardPreloadResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcFileDiscardPreloadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcFileDiscardPreloadResponse{Error: &pb.RpcFileDiscardPreloadResponseError{Code: pb.RpcFileDiscardPreloadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.FileDiscardPreload(context.Background(), in).Marshal()
	return resp
}

func FileDrop(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcFileDropResponse{Error: &pb.RpcFileDropResponseError{Code: pb.RpcFileDropResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcFileDropRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcFileDropResponse{Error: &pb.RpcFileDropResponseError{Code: pb.RpcFileDropResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.FileDrop(context.Background(), in).Marshal()
	return resp
}

func FileSpaceUsage(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcFileSpaceUsageResponse{Error: &pb.RpcFileSpaceUsageResponseError{Code: pb.RpcFileSpaceUsageResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcFileSpaceUsageRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcFileSpaceUsageResponse{Error: &pb.RpcFileSpaceUsageResponseError{Code: pb.RpcFileSpaceUsageResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.FileSpaceUsage(context.Background(), in).Marshal()
	return resp
}

func FileNodeUsage(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcFileNodeUsageResponse{Error: &pb.RpcFileNodeUsageResponseError{Code: pb.RpcFileNodeUsageResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcFileNodeUsageRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcFileNodeUsageResponse{Error: &pb.RpcFileNodeUsageResponseError{Code: pb.RpcFileNodeUsageResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.FileNodeUsage(context.Background(), in).Marshal()
	return resp
}

func NavigationListObjects(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcNavigationListObjectsResponse{Error: &pb.RpcNavigationListObjectsResponseError{Code: pb.RpcNavigationListObjectsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcNavigationListObjectsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcNavigationListObjectsResponse{Error: &pb.RpcNavigationListObjectsResponseError{Code: pb.RpcNavigationListObjectsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.NavigationListObjects(context.Background(), in).Marshal()
	return resp
}

func NavigationGetObjectInfoWithLinks(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcNavigationGetObjectInfoWithLinksResponse{Error: &pb.RpcNavigationGetObjectInfoWithLinksResponseError{Code: pb.RpcNavigationGetObjectInfoWithLinksResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcNavigationGetObjectInfoWithLinksRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcNavigationGetObjectInfoWithLinksResponse{Error: &pb.RpcNavigationGetObjectInfoWithLinksResponseError{Code: pb.RpcNavigationGetObjectInfoWithLinksResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.NavigationGetObjectInfoWithLinks(context.Background(), in).Marshal()
	return resp
}

func TemplateCreateFromObject(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcTemplateCreateFromObjectResponse{Error: &pb.RpcTemplateCreateFromObjectResponseError{Code: pb.RpcTemplateCreateFromObjectResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcTemplateCreateFromObjectRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcTemplateCreateFromObjectResponse{Error: &pb.RpcTemplateCreateFromObjectResponseError{Code: pb.RpcTemplateCreateFromObjectResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.TemplateCreateFromObject(context.Background(), in).Marshal()
	return resp
}

func TemplateClone(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcTemplateCloneResponse{Error: &pb.RpcTemplateCloneResponseError{Code: pb.RpcTemplateCloneResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcTemplateCloneRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcTemplateCloneResponse{Error: &pb.RpcTemplateCloneResponseError{Code: pb.RpcTemplateCloneResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.TemplateClone(context.Background(), in).Marshal()
	return resp
}

func TemplateExportAll(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcTemplateExportAllResponse{Error: &pb.RpcTemplateExportAllResponseError{Code: pb.RpcTemplateExportAllResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcTemplateExportAllRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcTemplateExportAllResponse{Error: &pb.RpcTemplateExportAllResponseError{Code: pb.RpcTemplateExportAllResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.TemplateExportAll(context.Background(), in).Marshal()
	return resp
}

func LinkPreview(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcLinkPreviewResponse{Error: &pb.RpcLinkPreviewResponseError{Code: pb.RpcLinkPreviewResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcLinkPreviewRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcLinkPreviewResponse{Error: &pb.RpcLinkPreviewResponseError{Code: pb.RpcLinkPreviewResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.LinkPreview(context.Background(), in).Marshal()
	return resp
}

func UnsplashSearch(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcUnsplashSearchResponse{Error: &pb.RpcUnsplashSearchResponseError{Code: pb.RpcUnsplashSearchResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcUnsplashSearchRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcUnsplashSearchResponse{Error: &pb.RpcUnsplashSearchResponseError{Code: pb.RpcUnsplashSearchResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.UnsplashSearch(context.Background(), in).Marshal()
	return resp
}

func UnsplashDownload(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcUnsplashDownloadResponse{Error: &pb.RpcUnsplashDownloadResponseError{Code: pb.RpcUnsplashDownloadResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcUnsplashDownloadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcUnsplashDownloadResponse{Error: &pb.RpcUnsplashDownloadResponseError{Code: pb.RpcUnsplashDownloadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.UnsplashDownload(context.Background(), in).Marshal()
	return resp
}

func GalleryDownloadManifest(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcGalleryDownloadManifestResponse{Error: &pb.RpcGalleryDownloadManifestResponseError{Code: pb.RpcGalleryDownloadManifestResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcGalleryDownloadManifestRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcGalleryDownloadManifestResponse{Error: &pb.RpcGalleryDownloadManifestResponseError{Code: pb.RpcGalleryDownloadManifestResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.GalleryDownloadManifest(context.Background(), in).Marshal()
	return resp
}

func GalleryDownloadIndex(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcGalleryDownloadIndexResponse{Error: &pb.RpcGalleryDownloadIndexResponseError{Code: pb.RpcGalleryDownloadIndexResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcGalleryDownloadIndexRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcGalleryDownloadIndexResponse{Error: &pb.RpcGalleryDownloadIndexResponseError{Code: pb.RpcGalleryDownloadIndexResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.GalleryDownloadIndex(context.Background(), in).Marshal()
	return resp
}

func BlockUpload(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockUploadResponse{Error: &pb.RpcBlockUploadResponseError{Code: pb.RpcBlockUploadResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockUploadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockUploadResponse{Error: &pb.RpcBlockUploadResponseError{Code: pb.RpcBlockUploadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockUpload(context.Background(), in).Marshal()
	return resp
}

func BlockReplace(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockReplaceResponse{Error: &pb.RpcBlockReplaceResponseError{Code: pb.RpcBlockReplaceResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockReplaceRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockReplaceResponse{Error: &pb.RpcBlockReplaceResponseError{Code: pb.RpcBlockReplaceResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockReplace(context.Background(), in).Marshal()
	return resp
}

func BlockCreate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockCreateResponse{Error: &pb.RpcBlockCreateResponseError{Code: pb.RpcBlockCreateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockCreateResponse{Error: &pb.RpcBlockCreateResponseError{Code: pb.RpcBlockCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockCreate(context.Background(), in).Marshal()
	return resp
}

func BlockSplit(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockSplitResponse{Error: &pb.RpcBlockSplitResponseError{Code: pb.RpcBlockSplitResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockSplitRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSplitResponse{Error: &pb.RpcBlockSplitResponseError{Code: pb.RpcBlockSplitResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSplit(context.Background(), in).Marshal()
	return resp
}

func BlockMerge(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockMergeResponse{Error: &pb.RpcBlockMergeResponseError{Code: pb.RpcBlockMergeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockMergeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockMergeResponse{Error: &pb.RpcBlockMergeResponseError{Code: pb.RpcBlockMergeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockMerge(context.Background(), in).Marshal()
	return resp
}

func BlockCopy(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockCopyResponse{Error: &pb.RpcBlockCopyResponseError{Code: pb.RpcBlockCopyResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockCopyRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockCopyResponse{Error: &pb.RpcBlockCopyResponseError{Code: pb.RpcBlockCopyResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockCopy(context.Background(), in).Marshal()
	return resp
}

func BlockPaste(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockPasteResponse{Error: &pb.RpcBlockPasteResponseError{Code: pb.RpcBlockPasteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockPasteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockPasteResponse{Error: &pb.RpcBlockPasteResponseError{Code: pb.RpcBlockPasteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockPaste(context.Background(), in).Marshal()
	return resp
}

func BlockCut(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockCutResponse{Error: &pb.RpcBlockCutResponseError{Code: pb.RpcBlockCutResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockCutRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockCutResponse{Error: &pb.RpcBlockCutResponseError{Code: pb.RpcBlockCutResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockCut(context.Background(), in).Marshal()
	return resp
}

func BlockSetFields(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockSetFieldsResponse{Error: &pb.RpcBlockSetFieldsResponseError{Code: pb.RpcBlockSetFieldsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockSetFieldsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetFieldsResponse{Error: &pb.RpcBlockSetFieldsResponseError{Code: pb.RpcBlockSetFieldsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetFields(context.Background(), in).Marshal()
	return resp
}

func BlockExport(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockExportResponse{Error: &pb.RpcBlockExportResponseError{Code: pb.RpcBlockExportResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockExportRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockExportResponse{Error: &pb.RpcBlockExportResponseError{Code: pb.RpcBlockExportResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockExport(context.Background(), in).Marshal()
	return resp
}

func BlockSetCarriage(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockSetCarriageResponse{Error: &pb.RpcBlockSetCarriageResponseError{Code: pb.RpcBlockSetCarriageResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockSetCarriageRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetCarriageResponse{Error: &pb.RpcBlockSetCarriageResponseError{Code: pb.RpcBlockSetCarriageResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetCarriage(context.Background(), in).Marshal()
	return resp
}

func BlockPreview(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockPreviewResponse{Error: &pb.RpcBlockPreviewResponseError{Code: pb.RpcBlockPreviewResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockPreviewRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockPreviewResponse{Error: &pb.RpcBlockPreviewResponseError{Code: pb.RpcBlockPreviewResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockPreview(context.Background(), in).Marshal()
	return resp
}

func BlockListDelete(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockListDeleteResponse{Error: &pb.RpcBlockListDeleteResponseError{Code: pb.RpcBlockListDeleteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockListDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListDeleteResponse{Error: &pb.RpcBlockListDeleteResponseError{Code: pb.RpcBlockListDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListDelete(context.Background(), in).Marshal()
	return resp
}

func BlockListMoveToExistingObject(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockListMoveToExistingObjectResponse{Error: &pb.RpcBlockListMoveToExistingObjectResponseError{Code: pb.RpcBlockListMoveToExistingObjectResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockListMoveToExistingObjectRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListMoveToExistingObjectResponse{Error: &pb.RpcBlockListMoveToExistingObjectResponseError{Code: pb.RpcBlockListMoveToExistingObjectResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListMoveToExistingObject(context.Background(), in).Marshal()
	return resp
}

func BlockListMoveToNewObject(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockListMoveToNewObjectResponse{Error: &pb.RpcBlockListMoveToNewObjectResponseError{Code: pb.RpcBlockListMoveToNewObjectResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockListMoveToNewObjectRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListMoveToNewObjectResponse{Error: &pb.RpcBlockListMoveToNewObjectResponseError{Code: pb.RpcBlockListMoveToNewObjectResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListMoveToNewObject(context.Background(), in).Marshal()
	return resp
}

func BlockListConvertToObjects(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockListConvertToObjectsResponse{Error: &pb.RpcBlockListConvertToObjectsResponseError{Code: pb.RpcBlockListConvertToObjectsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockListConvertToObjectsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListConvertToObjectsResponse{Error: &pb.RpcBlockListConvertToObjectsResponseError{Code: pb.RpcBlockListConvertToObjectsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListConvertToObjects(context.Background(), in).Marshal()
	return resp
}

func BlockListSetFields(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockListSetFieldsResponse{Error: &pb.RpcBlockListSetFieldsResponseError{Code: pb.RpcBlockListSetFieldsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockListSetFieldsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListSetFieldsResponse{Error: &pb.RpcBlockListSetFieldsResponseError{Code: pb.RpcBlockListSetFieldsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListSetFields(context.Background(), in).Marshal()
	return resp
}

func BlockListDuplicate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockListDuplicateResponse{Error: &pb.RpcBlockListDuplicateResponseError{Code: pb.RpcBlockListDuplicateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockListDuplicateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListDuplicateResponse{Error: &pb.RpcBlockListDuplicateResponseError{Code: pb.RpcBlockListDuplicateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListDuplicate(context.Background(), in).Marshal()
	return resp
}

func BlockListSetBackgroundColor(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockListSetBackgroundColorResponse{Error: &pb.RpcBlockListSetBackgroundColorResponseError{Code: pb.RpcBlockListSetBackgroundColorResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockListSetBackgroundColorRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListSetBackgroundColorResponse{Error: &pb.RpcBlockListSetBackgroundColorResponseError{Code: pb.RpcBlockListSetBackgroundColorResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListSetBackgroundColor(context.Background(), in).Marshal()
	return resp
}

func BlockListSetAlign(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockListSetAlignResponse{Error: &pb.RpcBlockListSetAlignResponseError{Code: pb.RpcBlockListSetAlignResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockListSetAlignRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListSetAlignResponse{Error: &pb.RpcBlockListSetAlignResponseError{Code: pb.RpcBlockListSetAlignResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListSetAlign(context.Background(), in).Marshal()
	return resp
}

func BlockListSetVerticalAlign(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockListSetVerticalAlignResponse{Error: &pb.RpcBlockListSetVerticalAlignResponseError{Code: pb.RpcBlockListSetVerticalAlignResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockListSetVerticalAlignRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListSetVerticalAlignResponse{Error: &pb.RpcBlockListSetVerticalAlignResponseError{Code: pb.RpcBlockListSetVerticalAlignResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListSetVerticalAlign(context.Background(), in).Marshal()
	return resp
}

func BlockListTurnInto(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockListTurnIntoResponse{Error: &pb.RpcBlockListTurnIntoResponseError{Code: pb.RpcBlockListTurnIntoResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockListTurnIntoRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListTurnIntoResponse{Error: &pb.RpcBlockListTurnIntoResponseError{Code: pb.RpcBlockListTurnIntoResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListTurnInto(context.Background(), in).Marshal()
	return resp
}

func BlockTextSetText(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTextSetTextResponse{Error: &pb.RpcBlockTextSetTextResponseError{Code: pb.RpcBlockTextSetTextResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTextSetTextRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTextSetTextResponse{Error: &pb.RpcBlockTextSetTextResponseError{Code: pb.RpcBlockTextSetTextResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTextSetText(context.Background(), in).Marshal()
	return resp
}

func BlockTextSetColor(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTextSetColorResponse{Error: &pb.RpcBlockTextSetColorResponseError{Code: pb.RpcBlockTextSetColorResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTextSetColorRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTextSetColorResponse{Error: &pb.RpcBlockTextSetColorResponseError{Code: pb.RpcBlockTextSetColorResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTextSetColor(context.Background(), in).Marshal()
	return resp
}

func BlockTextSetStyle(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTextSetStyleResponse{Error: &pb.RpcBlockTextSetStyleResponseError{Code: pb.RpcBlockTextSetStyleResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTextSetStyleRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTextSetStyleResponse{Error: &pb.RpcBlockTextSetStyleResponseError{Code: pb.RpcBlockTextSetStyleResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTextSetStyle(context.Background(), in).Marshal()
	return resp
}

func BlockTextSetChecked(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTextSetCheckedResponse{Error: &pb.RpcBlockTextSetCheckedResponseError{Code: pb.RpcBlockTextSetCheckedResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTextSetCheckedRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTextSetCheckedResponse{Error: &pb.RpcBlockTextSetCheckedResponseError{Code: pb.RpcBlockTextSetCheckedResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTextSetChecked(context.Background(), in).Marshal()
	return resp
}

func BlockTextSetIcon(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTextSetIconResponse{Error: &pb.RpcBlockTextSetIconResponseError{Code: pb.RpcBlockTextSetIconResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTextSetIconRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTextSetIconResponse{Error: &pb.RpcBlockTextSetIconResponseError{Code: pb.RpcBlockTextSetIconResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTextSetIcon(context.Background(), in).Marshal()
	return resp
}

func BlockTextListSetColor(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTextListSetColorResponse{Error: &pb.RpcBlockTextListSetColorResponseError{Code: pb.RpcBlockTextListSetColorResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTextListSetColorRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTextListSetColorResponse{Error: &pb.RpcBlockTextListSetColorResponseError{Code: pb.RpcBlockTextListSetColorResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTextListSetColor(context.Background(), in).Marshal()
	return resp
}

func BlockTextListSetMark(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTextListSetMarkResponse{Error: &pb.RpcBlockTextListSetMarkResponseError{Code: pb.RpcBlockTextListSetMarkResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTextListSetMarkRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTextListSetMarkResponse{Error: &pb.RpcBlockTextListSetMarkResponseError{Code: pb.RpcBlockTextListSetMarkResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTextListSetMark(context.Background(), in).Marshal()
	return resp
}

func BlockTextListSetStyle(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTextListSetStyleResponse{Error: &pb.RpcBlockTextListSetStyleResponseError{Code: pb.RpcBlockTextListSetStyleResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTextListSetStyleRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTextListSetStyleResponse{Error: &pb.RpcBlockTextListSetStyleResponseError{Code: pb.RpcBlockTextListSetStyleResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTextListSetStyle(context.Background(), in).Marshal()
	return resp
}

func BlockTextListClearStyle(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTextListClearStyleResponse{Error: &pb.RpcBlockTextListClearStyleResponseError{Code: pb.RpcBlockTextListClearStyleResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTextListClearStyleRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTextListClearStyleResponse{Error: &pb.RpcBlockTextListClearStyleResponseError{Code: pb.RpcBlockTextListClearStyleResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTextListClearStyle(context.Background(), in).Marshal()
	return resp
}

func BlockTextListClearContent(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTextListClearContentResponse{Error: &pb.RpcBlockTextListClearContentResponseError{Code: pb.RpcBlockTextListClearContentResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTextListClearContentRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTextListClearContentResponse{Error: &pb.RpcBlockTextListClearContentResponseError{Code: pb.RpcBlockTextListClearContentResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTextListClearContent(context.Background(), in).Marshal()
	return resp
}

func BlockFileSetName(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockFileSetNameResponse{Error: &pb.RpcBlockFileSetNameResponseError{Code: pb.RpcBlockFileSetNameResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockFileSetNameRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockFileSetNameResponse{Error: &pb.RpcBlockFileSetNameResponseError{Code: pb.RpcBlockFileSetNameResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockFileSetName(context.Background(), in).Marshal()
	return resp
}

func BlockFileSetTargetObjectId(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockFileSetTargetObjectIdResponse{Error: &pb.RpcBlockFileSetTargetObjectIdResponseError{Code: pb.RpcBlockFileSetTargetObjectIdResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockFileSetTargetObjectIdRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockFileSetTargetObjectIdResponse{Error: &pb.RpcBlockFileSetTargetObjectIdResponseError{Code: pb.RpcBlockFileSetTargetObjectIdResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockFileSetTargetObjectId(context.Background(), in).Marshal()
	return resp
}

func BlockImageSetName(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockImageSetNameResponse{Error: &pb.RpcBlockImageSetNameResponseError{Code: pb.RpcBlockImageSetNameResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockImageSetNameRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockImageSetNameResponse{Error: &pb.RpcBlockImageSetNameResponseError{Code: pb.RpcBlockImageSetNameResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockImageSetName(context.Background(), in).Marshal()
	return resp
}

func BlockVideoSetName(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockVideoSetNameResponse{Error: &pb.RpcBlockVideoSetNameResponseError{Code: pb.RpcBlockVideoSetNameResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockVideoSetNameRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockVideoSetNameResponse{Error: &pb.RpcBlockVideoSetNameResponseError{Code: pb.RpcBlockVideoSetNameResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockVideoSetName(context.Background(), in).Marshal()
	return resp
}

func BlockFileCreateAndUpload(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockFileCreateAndUploadResponse{Error: &pb.RpcBlockFileCreateAndUploadResponseError{Code: pb.RpcBlockFileCreateAndUploadResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockFileCreateAndUploadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockFileCreateAndUploadResponse{Error: &pb.RpcBlockFileCreateAndUploadResponseError{Code: pb.RpcBlockFileCreateAndUploadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockFileCreateAndUpload(context.Background(), in).Marshal()
	return resp
}

func BlockFileListSetStyle(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockFileListSetStyleResponse{Error: &pb.RpcBlockFileListSetStyleResponseError{Code: pb.RpcBlockFileListSetStyleResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockFileListSetStyleRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockFileListSetStyleResponse{Error: &pb.RpcBlockFileListSetStyleResponseError{Code: pb.RpcBlockFileListSetStyleResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockFileListSetStyle(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewViewCreate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewViewCreateResponse{Error: &pb.RpcBlockDataviewViewCreateResponseError{Code: pb.RpcBlockDataviewViewCreateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewViewCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewViewCreateResponse{Error: &pb.RpcBlockDataviewViewCreateResponseError{Code: pb.RpcBlockDataviewViewCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewViewCreate(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewViewDelete(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewViewDeleteResponse{Error: &pb.RpcBlockDataviewViewDeleteResponseError{Code: pb.RpcBlockDataviewViewDeleteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewViewDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewViewDeleteResponse{Error: &pb.RpcBlockDataviewViewDeleteResponseError{Code: pb.RpcBlockDataviewViewDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewViewDelete(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewViewUpdate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewViewUpdateResponse{Error: &pb.RpcBlockDataviewViewUpdateResponseError{Code: pb.RpcBlockDataviewViewUpdateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewViewUpdateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewViewUpdateResponse{Error: &pb.RpcBlockDataviewViewUpdateResponseError{Code: pb.RpcBlockDataviewViewUpdateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewViewUpdate(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewViewSetActive(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewViewSetActiveResponse{Error: &pb.RpcBlockDataviewViewSetActiveResponseError{Code: pb.RpcBlockDataviewViewSetActiveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewViewSetActiveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewViewSetActiveResponse{Error: &pb.RpcBlockDataviewViewSetActiveResponseError{Code: pb.RpcBlockDataviewViewSetActiveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewViewSetActive(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewViewSetPosition(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewViewSetPositionResponse{Error: &pb.RpcBlockDataviewViewSetPositionResponseError{Code: pb.RpcBlockDataviewViewSetPositionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewViewSetPositionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewViewSetPositionResponse{Error: &pb.RpcBlockDataviewViewSetPositionResponseError{Code: pb.RpcBlockDataviewViewSetPositionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewViewSetPosition(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewSetSource(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewSetSourceResponse{Error: &pb.RpcBlockDataviewSetSourceResponseError{Code: pb.RpcBlockDataviewSetSourceResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewSetSourceRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewSetSourceResponse{Error: &pb.RpcBlockDataviewSetSourceResponseError{Code: pb.RpcBlockDataviewSetSourceResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewSetSource(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewRelationSet(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewRelationSetResponse{Error: &pb.RpcBlockDataviewRelationSetResponseError{Code: pb.RpcBlockDataviewRelationSetResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewRelationSetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRelationSetResponse{Error: &pb.RpcBlockDataviewRelationSetResponseError{Code: pb.RpcBlockDataviewRelationSetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRelationSet(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewRelationAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewRelationAddResponse{Error: &pb.RpcBlockDataviewRelationAddResponseError{Code: pb.RpcBlockDataviewRelationAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewRelationAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRelationAddResponse{Error: &pb.RpcBlockDataviewRelationAddResponseError{Code: pb.RpcBlockDataviewRelationAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRelationAdd(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewRelationDelete(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewRelationDeleteResponse{Error: &pb.RpcBlockDataviewRelationDeleteResponseError{Code: pb.RpcBlockDataviewRelationDeleteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewRelationDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRelationDeleteResponse{Error: &pb.RpcBlockDataviewRelationDeleteResponseError{Code: pb.RpcBlockDataviewRelationDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRelationDelete(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewGroupOrderUpdate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewGroupOrderUpdateResponse{Error: &pb.RpcBlockDataviewGroupOrderUpdateResponseError{Code: pb.RpcBlockDataviewGroupOrderUpdateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewGroupOrderUpdateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewGroupOrderUpdateResponse{Error: &pb.RpcBlockDataviewGroupOrderUpdateResponseError{Code: pb.RpcBlockDataviewGroupOrderUpdateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewGroupOrderUpdate(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewObjectOrderUpdate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewObjectOrderUpdateResponse{Error: &pb.RpcBlockDataviewObjectOrderUpdateResponseError{Code: pb.RpcBlockDataviewObjectOrderUpdateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewObjectOrderUpdateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewObjectOrderUpdateResponse{Error: &pb.RpcBlockDataviewObjectOrderUpdateResponseError{Code: pb.RpcBlockDataviewObjectOrderUpdateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewObjectOrderUpdate(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewObjectOrderMove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewObjectOrderMoveResponse{Error: &pb.RpcBlockDataviewObjectOrderMoveResponseError{Code: pb.RpcBlockDataviewObjectOrderMoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewObjectOrderMoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewObjectOrderMoveResponse{Error: &pb.RpcBlockDataviewObjectOrderMoveResponseError{Code: pb.RpcBlockDataviewObjectOrderMoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewObjectOrderMove(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewCreateFromExistingObject(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewCreateFromExistingObjectResponse{Error: &pb.RpcBlockDataviewCreateFromExistingObjectResponseError{Code: pb.RpcBlockDataviewCreateFromExistingObjectResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewCreateFromExistingObjectRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewCreateFromExistingObjectResponse{Error: &pb.RpcBlockDataviewCreateFromExistingObjectResponseError{Code: pb.RpcBlockDataviewCreateFromExistingObjectResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewCreateFromExistingObject(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewFilterAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewFilterAddResponse{Error: &pb.RpcBlockDataviewFilterAddResponseError{Code: pb.RpcBlockDataviewFilterAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewFilterAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewFilterAddResponse{Error: &pb.RpcBlockDataviewFilterAddResponseError{Code: pb.RpcBlockDataviewFilterAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewFilterAdd(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewFilterRemove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewFilterRemoveResponse{Error: &pb.RpcBlockDataviewFilterRemoveResponseError{Code: pb.RpcBlockDataviewFilterRemoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewFilterRemoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewFilterRemoveResponse{Error: &pb.RpcBlockDataviewFilterRemoveResponseError{Code: pb.RpcBlockDataviewFilterRemoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewFilterRemove(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewFilterReplace(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewFilterReplaceResponse{Error: &pb.RpcBlockDataviewFilterReplaceResponseError{Code: pb.RpcBlockDataviewFilterReplaceResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewFilterReplaceRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewFilterReplaceResponse{Error: &pb.RpcBlockDataviewFilterReplaceResponseError{Code: pb.RpcBlockDataviewFilterReplaceResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewFilterReplace(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewFilterSort(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewFilterSortResponse{Error: &pb.RpcBlockDataviewFilterSortResponseError{Code: pb.RpcBlockDataviewFilterSortResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewFilterSortRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewFilterSortResponse{Error: &pb.RpcBlockDataviewFilterSortResponseError{Code: pb.RpcBlockDataviewFilterSortResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewFilterSort(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewSortAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewSortAddResponse{Error: &pb.RpcBlockDataviewSortAddResponseError{Code: pb.RpcBlockDataviewSortAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewSortAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewSortAddResponse{Error: &pb.RpcBlockDataviewSortAddResponseError{Code: pb.RpcBlockDataviewSortAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewSortAdd(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewSortRemove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewSortRemoveResponse{Error: &pb.RpcBlockDataviewSortRemoveResponseError{Code: pb.RpcBlockDataviewSortRemoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewSortRemoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewSortRemoveResponse{Error: &pb.RpcBlockDataviewSortRemoveResponseError{Code: pb.RpcBlockDataviewSortRemoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewSortRemove(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewSortReplace(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewSortReplaceResponse{Error: &pb.RpcBlockDataviewSortReplaceResponseError{Code: pb.RpcBlockDataviewSortReplaceResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewSortReplaceRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewSortReplaceResponse{Error: &pb.RpcBlockDataviewSortReplaceResponseError{Code: pb.RpcBlockDataviewSortReplaceResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewSortReplace(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewSortSort(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewSortSSortResponse{Error: &pb.RpcBlockDataviewSortSSortResponseError{Code: pb.RpcBlockDataviewSortSSortResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewSortSSortRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewSortSSortResponse{Error: &pb.RpcBlockDataviewSortSSortResponseError{Code: pb.RpcBlockDataviewSortSSortResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewSortSort(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewViewRelationAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewViewRelationAddResponse{Error: &pb.RpcBlockDataviewViewRelationAddResponseError{Code: pb.RpcBlockDataviewViewRelationAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewViewRelationAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewViewRelationAddResponse{Error: &pb.RpcBlockDataviewViewRelationAddResponseError{Code: pb.RpcBlockDataviewViewRelationAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewViewRelationAdd(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewViewRelationRemove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewViewRelationRemoveResponse{Error: &pb.RpcBlockDataviewViewRelationRemoveResponseError{Code: pb.RpcBlockDataviewViewRelationRemoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewViewRelationRemoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewViewRelationRemoveResponse{Error: &pb.RpcBlockDataviewViewRelationRemoveResponseError{Code: pb.RpcBlockDataviewViewRelationRemoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewViewRelationRemove(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewViewRelationReplace(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewViewRelationReplaceResponse{Error: &pb.RpcBlockDataviewViewRelationReplaceResponseError{Code: pb.RpcBlockDataviewViewRelationReplaceResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewViewRelationReplaceRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewViewRelationReplaceResponse{Error: &pb.RpcBlockDataviewViewRelationReplaceResponseError{Code: pb.RpcBlockDataviewViewRelationReplaceResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewViewRelationReplace(context.Background(), in).Marshal()
	return resp
}

func BlockDataviewViewRelationSort(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDataviewViewRelationSortResponse{Error: &pb.RpcBlockDataviewViewRelationSortResponseError{Code: pb.RpcBlockDataviewViewRelationSortResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDataviewViewRelationSortRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewViewRelationSortResponse{Error: &pb.RpcBlockDataviewViewRelationSortResponseError{Code: pb.RpcBlockDataviewViewRelationSortResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewViewRelationSort(context.Background(), in).Marshal()
	return resp
}

func BlockTableCreate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableCreateResponse{Error: &pb.RpcBlockTableCreateResponseError{Code: pb.RpcBlockTableCreateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableCreateResponse{Error: &pb.RpcBlockTableCreateResponseError{Code: pb.RpcBlockTableCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableCreate(context.Background(), in).Marshal()
	return resp
}

func BlockTableExpand(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableExpandResponse{Error: &pb.RpcBlockTableExpandResponseError{Code: pb.RpcBlockTableExpandResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableExpandRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableExpandResponse{Error: &pb.RpcBlockTableExpandResponseError{Code: pb.RpcBlockTableExpandResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableExpand(context.Background(), in).Marshal()
	return resp
}

func BlockTableRowCreate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableRowCreateResponse{Error: &pb.RpcBlockTableRowCreateResponseError{Code: pb.RpcBlockTableRowCreateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableRowCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableRowCreateResponse{Error: &pb.RpcBlockTableRowCreateResponseError{Code: pb.RpcBlockTableRowCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableRowCreate(context.Background(), in).Marshal()
	return resp
}

func BlockTableRowDelete(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableRowDeleteResponse{Error: &pb.RpcBlockTableRowDeleteResponseError{Code: pb.RpcBlockTableRowDeleteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableRowDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableRowDeleteResponse{Error: &pb.RpcBlockTableRowDeleteResponseError{Code: pb.RpcBlockTableRowDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableRowDelete(context.Background(), in).Marshal()
	return resp
}

func BlockTableRowDuplicate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableRowDuplicateResponse{Error: &pb.RpcBlockTableRowDuplicateResponseError{Code: pb.RpcBlockTableRowDuplicateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableRowDuplicateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableRowDuplicateResponse{Error: &pb.RpcBlockTableRowDuplicateResponseError{Code: pb.RpcBlockTableRowDuplicateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableRowDuplicate(context.Background(), in).Marshal()
	return resp
}

func BlockTableRowSetHeader(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableRowSetHeaderResponse{Error: &pb.RpcBlockTableRowSetHeaderResponseError{Code: pb.RpcBlockTableRowSetHeaderResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableRowSetHeaderRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableRowSetHeaderResponse{Error: &pb.RpcBlockTableRowSetHeaderResponseError{Code: pb.RpcBlockTableRowSetHeaderResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableRowSetHeader(context.Background(), in).Marshal()
	return resp
}

func BlockTableColumnCreate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableColumnCreateResponse{Error: &pb.RpcBlockTableColumnCreateResponseError{Code: pb.RpcBlockTableColumnCreateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableColumnCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableColumnCreateResponse{Error: &pb.RpcBlockTableColumnCreateResponseError{Code: pb.RpcBlockTableColumnCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableColumnCreate(context.Background(), in).Marshal()
	return resp
}

func BlockTableColumnMove(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableColumnMoveResponse{Error: &pb.RpcBlockTableColumnMoveResponseError{Code: pb.RpcBlockTableColumnMoveResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableColumnMoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableColumnMoveResponse{Error: &pb.RpcBlockTableColumnMoveResponseError{Code: pb.RpcBlockTableColumnMoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableColumnMove(context.Background(), in).Marshal()
	return resp
}

func BlockTableColumnDelete(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableColumnDeleteResponse{Error: &pb.RpcBlockTableColumnDeleteResponseError{Code: pb.RpcBlockTableColumnDeleteResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableColumnDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableColumnDeleteResponse{Error: &pb.RpcBlockTableColumnDeleteResponseError{Code: pb.RpcBlockTableColumnDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableColumnDelete(context.Background(), in).Marshal()
	return resp
}

func BlockTableColumnDuplicate(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableColumnDuplicateResponse{Error: &pb.RpcBlockTableColumnDuplicateResponseError{Code: pb.RpcBlockTableColumnDuplicateResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableColumnDuplicateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableColumnDuplicateResponse{Error: &pb.RpcBlockTableColumnDuplicateResponseError{Code: pb.RpcBlockTableColumnDuplicateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableColumnDuplicate(context.Background(), in).Marshal()
	return resp
}

func BlockTableRowListFill(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableRowListFillResponse{Error: &pb.RpcBlockTableRowListFillResponseError{Code: pb.RpcBlockTableRowListFillResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableRowListFillRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableRowListFillResponse{Error: &pb.RpcBlockTableRowListFillResponseError{Code: pb.RpcBlockTableRowListFillResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableRowListFill(context.Background(), in).Marshal()
	return resp
}

func BlockTableRowListClean(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableRowListCleanResponse{Error: &pb.RpcBlockTableRowListCleanResponseError{Code: pb.RpcBlockTableRowListCleanResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableRowListCleanRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableRowListCleanResponse{Error: &pb.RpcBlockTableRowListCleanResponseError{Code: pb.RpcBlockTableRowListCleanResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableRowListClean(context.Background(), in).Marshal()
	return resp
}

func BlockTableColumnListFill(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableColumnListFillResponse{Error: &pb.RpcBlockTableColumnListFillResponseError{Code: pb.RpcBlockTableColumnListFillResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableColumnListFillRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableColumnListFillResponse{Error: &pb.RpcBlockTableColumnListFillResponseError{Code: pb.RpcBlockTableColumnListFillResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableColumnListFill(context.Background(), in).Marshal()
	return resp
}

func BlockTableSort(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockTableSortResponse{Error: &pb.RpcBlockTableSortResponseError{Code: pb.RpcBlockTableSortResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockTableSortRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockTableSortResponse{Error: &pb.RpcBlockTableSortResponseError{Code: pb.RpcBlockTableSortResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockTableSort(context.Background(), in).Marshal()
	return resp
}

func BlockCreateWidget(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockCreateWidgetResponse{Error: &pb.RpcBlockCreateWidgetResponseError{Code: pb.RpcBlockCreateWidgetResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockCreateWidgetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockCreateWidgetResponse{Error: &pb.RpcBlockCreateWidgetResponseError{Code: pb.RpcBlockCreateWidgetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockCreateWidget(context.Background(), in).Marshal()
	return resp
}

func BlockWidgetSetTargetId(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockWidgetSetTargetIdResponse{Error: &pb.RpcBlockWidgetSetTargetIdResponseError{Code: pb.RpcBlockWidgetSetTargetIdResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockWidgetSetTargetIdRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockWidgetSetTargetIdResponse{Error: &pb.RpcBlockWidgetSetTargetIdResponseError{Code: pb.RpcBlockWidgetSetTargetIdResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockWidgetSetTargetId(context.Background(), in).Marshal()
	return resp
}

func BlockWidgetSetLayout(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockWidgetSetLayoutResponse{Error: &pb.RpcBlockWidgetSetLayoutResponseError{Code: pb.RpcBlockWidgetSetLayoutResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockWidgetSetLayoutRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockWidgetSetLayoutResponse{Error: &pb.RpcBlockWidgetSetLayoutResponseError{Code: pb.RpcBlockWidgetSetLayoutResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockWidgetSetLayout(context.Background(), in).Marshal()
	return resp
}

func BlockWidgetSetLimit(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockWidgetSetLimitResponse{Error: &pb.RpcBlockWidgetSetLimitResponseError{Code: pb.RpcBlockWidgetSetLimitResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockWidgetSetLimitRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockWidgetSetLimitResponse{Error: &pb.RpcBlockWidgetSetLimitResponseError{Code: pb.RpcBlockWidgetSetLimitResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockWidgetSetLimit(context.Background(), in).Marshal()
	return resp
}

func BlockWidgetSetViewId(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockWidgetSetViewIdResponse{Error: &pb.RpcBlockWidgetSetViewIdResponseError{Code: pb.RpcBlockWidgetSetViewIdResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockWidgetSetViewIdRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockWidgetSetViewIdResponse{Error: &pb.RpcBlockWidgetSetViewIdResponseError{Code: pb.RpcBlockWidgetSetViewIdResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockWidgetSetViewId(context.Background(), in).Marshal()
	return resp
}

func BlockLinkCreateWithObject(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockLinkCreateWithObjectResponse{Error: &pb.RpcBlockLinkCreateWithObjectResponseError{Code: pb.RpcBlockLinkCreateWithObjectResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockLinkCreateWithObjectRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockLinkCreateWithObjectResponse{Error: &pb.RpcBlockLinkCreateWithObjectResponseError{Code: pb.RpcBlockLinkCreateWithObjectResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockLinkCreateWithObject(context.Background(), in).Marshal()
	return resp
}

func BlockLinkListSetAppearance(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockLinkListSetAppearanceResponse{Error: &pb.RpcBlockLinkListSetAppearanceResponseError{Code: pb.RpcBlockLinkListSetAppearanceResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockLinkListSetAppearanceRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockLinkListSetAppearanceResponse{Error: &pb.RpcBlockLinkListSetAppearanceResponseError{Code: pb.RpcBlockLinkListSetAppearanceResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockLinkListSetAppearance(context.Background(), in).Marshal()
	return resp
}

func BlockBookmarkFetch(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockBookmarkFetchResponse{Error: &pb.RpcBlockBookmarkFetchResponseError{Code: pb.RpcBlockBookmarkFetchResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockBookmarkFetchRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockBookmarkFetchResponse{Error: &pb.RpcBlockBookmarkFetchResponseError{Code: pb.RpcBlockBookmarkFetchResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockBookmarkFetch(context.Background(), in).Marshal()
	return resp
}

func BlockBookmarkCreateAndFetch(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockBookmarkCreateAndFetchResponse{Error: &pb.RpcBlockBookmarkCreateAndFetchResponseError{Code: pb.RpcBlockBookmarkCreateAndFetchResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockBookmarkCreateAndFetchRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockBookmarkCreateAndFetchResponse{Error: &pb.RpcBlockBookmarkCreateAndFetchResponseError{Code: pb.RpcBlockBookmarkCreateAndFetchResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockBookmarkCreateAndFetch(context.Background(), in).Marshal()
	return resp
}

func BlockRelationSetKey(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockRelationSetKeyResponse{Error: &pb.RpcBlockRelationSetKeyResponseError{Code: pb.RpcBlockRelationSetKeyResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockRelationSetKeyRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockRelationSetKeyResponse{Error: &pb.RpcBlockRelationSetKeyResponseError{Code: pb.RpcBlockRelationSetKeyResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockRelationSetKey(context.Background(), in).Marshal()
	return resp
}

func BlockRelationAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockRelationAddResponse{Error: &pb.RpcBlockRelationAddResponseError{Code: pb.RpcBlockRelationAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockRelationAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockRelationAddResponse{Error: &pb.RpcBlockRelationAddResponseError{Code: pb.RpcBlockRelationAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockRelationAdd(context.Background(), in).Marshal()
	return resp
}

func BlockDivListSetStyle(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockDivListSetStyleResponse{Error: &pb.RpcBlockDivListSetStyleResponseError{Code: pb.RpcBlockDivListSetStyleResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockDivListSetStyleRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDivListSetStyleResponse{Error: &pb.RpcBlockDivListSetStyleResponseError{Code: pb.RpcBlockDivListSetStyleResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDivListSetStyle(context.Background(), in).Marshal()
	return resp
}

func BlockLatexSetText(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBlockLatexSetTextResponse{Error: &pb.RpcBlockLatexSetTextResponseError{Code: pb.RpcBlockLatexSetTextResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBlockLatexSetTextRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockLatexSetTextResponse{Error: &pb.RpcBlockLatexSetTextResponseError{Code: pb.RpcBlockLatexSetTextResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockLatexSetText(context.Background(), in).Marshal()
	return resp
}

func ProcessCancel(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcProcessCancelResponse{Error: &pb.RpcProcessCancelResponseError{Code: pb.RpcProcessCancelResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcProcessCancelRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcProcessCancelResponse{Error: &pb.RpcProcessCancelResponseError{Code: pb.RpcProcessCancelResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ProcessCancel(context.Background(), in).Marshal()
	return resp
}

func ProcessSubscribe(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcProcessSubscribeResponse{Error: &pb.RpcProcessSubscribeResponseError{Code: pb.RpcProcessSubscribeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcProcessSubscribeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcProcessSubscribeResponse{Error: &pb.RpcProcessSubscribeResponseError{Code: pb.RpcProcessSubscribeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ProcessSubscribe(context.Background(), in).Marshal()
	return resp
}

func ProcessUnsubscribe(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcProcessUnsubscribeResponse{Error: &pb.RpcProcessUnsubscribeResponseError{Code: pb.RpcProcessUnsubscribeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcProcessUnsubscribeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcProcessUnsubscribeResponse{Error: &pb.RpcProcessUnsubscribeResponseError{Code: pb.RpcProcessUnsubscribeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ProcessUnsubscribe(context.Background(), in).Marshal()
	return resp
}

func LogSend(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcLogSendResponse{Error: &pb.RpcLogSendResponseError{Code: pb.RpcLogSendResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcLogSendRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcLogSendResponse{Error: &pb.RpcLogSendResponseError{Code: pb.RpcLogSendResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.LogSend(context.Background(), in).Marshal()
	return resp
}

func DebugStat(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugStatResponse{Error: &pb.RpcDebugStatResponseError{Code: pb.RpcDebugStatResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugStatRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugStatResponse{Error: &pb.RpcDebugStatResponseError{Code: pb.RpcDebugStatResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugStat(context.Background(), in).Marshal()
	return resp
}

func DebugTree(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugTreeResponse{Error: &pb.RpcDebugTreeResponseError{Code: pb.RpcDebugTreeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugTreeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugTreeResponse{Error: &pb.RpcDebugTreeResponseError{Code: pb.RpcDebugTreeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugTree(context.Background(), in).Marshal()
	return resp
}

func DebugTreeHeads(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugTreeHeadsResponse{Error: &pb.RpcDebugTreeHeadsResponseError{Code: pb.RpcDebugTreeHeadsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugTreeHeadsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugTreeHeadsResponse{Error: &pb.RpcDebugTreeHeadsResponseError{Code: pb.RpcDebugTreeHeadsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugTreeHeads(context.Background(), in).Marshal()
	return resp
}

func DebugSpaceSummary(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugSpaceSummaryResponse{Error: &pb.RpcDebugSpaceSummaryResponseError{Code: pb.RpcDebugSpaceSummaryResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugSpaceSummaryRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugSpaceSummaryResponse{Error: &pb.RpcDebugSpaceSummaryResponseError{Code: pb.RpcDebugSpaceSummaryResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugSpaceSummary(context.Background(), in).Marshal()
	return resp
}

func DebugStackGoroutines(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugStackGoroutinesResponse{Error: &pb.RpcDebugStackGoroutinesResponseError{Code: pb.RpcDebugStackGoroutinesResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugStackGoroutinesRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugStackGoroutinesResponse{Error: &pb.RpcDebugStackGoroutinesResponseError{Code: pb.RpcDebugStackGoroutinesResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugStackGoroutines(context.Background(), in).Marshal()
	return resp
}

func DebugExportLocalstore(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugExportLocalstoreResponse{Error: &pb.RpcDebugExportLocalstoreResponseError{Code: pb.RpcDebugExportLocalstoreResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugExportLocalstoreRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugExportLocalstoreResponse{Error: &pb.RpcDebugExportLocalstoreResponseError{Code: pb.RpcDebugExportLocalstoreResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugExportLocalstore(context.Background(), in).Marshal()
	return resp
}

func DebugPing(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugPingResponse{Error: &pb.RpcDebugPingResponseError{Code: pb.RpcDebugPingResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugPingRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugPingResponse{Error: &pb.RpcDebugPingResponseError{Code: pb.RpcDebugPingResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugPing(context.Background(), in).Marshal()
	return resp
}

func DebugSubscriptions(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugSubscriptionsResponse{Error: &pb.RpcDebugSubscriptionsResponseError{Code: pb.RpcDebugSubscriptionsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugSubscriptionsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugSubscriptionsResponse{Error: &pb.RpcDebugSubscriptionsResponseError{Code: pb.RpcDebugSubscriptionsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugSubscriptions(context.Background(), in).Marshal()
	return resp
}

func DebugOpenedObjects(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugOpenedObjectsResponse{Error: &pb.RpcDebugOpenedObjectsResponseError{Code: pb.RpcDebugOpenedObjectsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugOpenedObjectsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugOpenedObjectsResponse{Error: &pb.RpcDebugOpenedObjectsResponseError{Code: pb.RpcDebugOpenedObjectsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugOpenedObjects(context.Background(), in).Marshal()
	return resp
}

func DebugRunProfiler(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugRunProfilerResponse{Error: &pb.RpcDebugRunProfilerResponseError{Code: pb.RpcDebugRunProfilerResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugRunProfilerRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugRunProfilerResponse{Error: &pb.RpcDebugRunProfilerResponseError{Code: pb.RpcDebugRunProfilerResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugRunProfiler(context.Background(), in).Marshal()
	return resp
}

func DebugAccountSelectTrace(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugAccountSelectTraceResponse{Error: &pb.RpcDebugAccountSelectTraceResponseError{Code: pb.RpcDebugAccountSelectTraceResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugAccountSelectTraceRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugAccountSelectTraceResponse{Error: &pb.RpcDebugAccountSelectTraceResponseError{Code: pb.RpcDebugAccountSelectTraceResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugAccountSelectTrace(context.Background(), in).Marshal()
	return resp
}

func DebugAnystoreObjectChanges(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugAnystoreObjectChangesResponse{Error: &pb.RpcDebugAnystoreObjectChangesResponseError{Code: pb.RpcDebugAnystoreObjectChangesResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugAnystoreObjectChangesRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugAnystoreObjectChangesResponse{Error: &pb.RpcDebugAnystoreObjectChangesResponseError{Code: pb.RpcDebugAnystoreObjectChangesResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugAnystoreObjectChanges(context.Background(), in).Marshal()
	return resp
}

func DebugNetCheck(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugNetCheckResponse{Error: &pb.RpcDebugNetCheckResponseError{Code: pb.RpcDebugNetCheckResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugNetCheckRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugNetCheckResponse{Error: &pb.RpcDebugNetCheckResponseError{Code: pb.RpcDebugNetCheckResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugNetCheck(context.Background(), in).Marshal()
	return resp
}

func DebugExportLog(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDebugExportLogResponse{Error: &pb.RpcDebugExportLogResponseError{Code: pb.RpcDebugExportLogResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDebugExportLogRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugExportLogResponse{Error: &pb.RpcDebugExportLogResponseError{Code: pb.RpcDebugExportLogResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugExportLog(context.Background(), in).Marshal()
	return resp
}

func InitialSetParameters(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcInitialSetParametersResponse{Error: &pb.RpcInitialSetParametersResponseError{Code: pb.RpcInitialSetParametersResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcInitialSetParametersRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcInitialSetParametersResponse{Error: &pb.RpcInitialSetParametersResponseError{Code: pb.RpcInitialSetParametersResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.InitialSetParameters(context.Background(), in).Marshal()
	return resp
}

func NotificationList(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcNotificationListResponse{Error: &pb.RpcNotificationListResponseError{Code: pb.RpcNotificationListResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcNotificationListRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcNotificationListResponse{Error: &pb.RpcNotificationListResponseError{Code: pb.RpcNotificationListResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.NotificationList(context.Background(), in).Marshal()
	return resp
}

func NotificationReply(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcNotificationReplyResponse{Error: &pb.RpcNotificationReplyResponseError{Code: pb.RpcNotificationReplyResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcNotificationReplyRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcNotificationReplyResponse{Error: &pb.RpcNotificationReplyResponseError{Code: pb.RpcNotificationReplyResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.NotificationReply(context.Background(), in).Marshal()
	return resp
}

func NotificationTest(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcNotificationTestResponse{Error: &pb.RpcNotificationTestResponseError{Code: pb.RpcNotificationTestResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcNotificationTestRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcNotificationTestResponse{Error: &pb.RpcNotificationTestResponseError{Code: pb.RpcNotificationTestResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.NotificationTest(context.Background(), in).Marshal()
	return resp
}

func MembershipGetStatus(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipGetStatusResponse{Error: &pb.RpcMembershipGetStatusResponseError{Code: pb.RpcMembershipGetStatusResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipGetStatusRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipGetStatusResponse{Error: &pb.RpcMembershipGetStatusResponseError{Code: pb.RpcMembershipGetStatusResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipGetStatus(context.Background(), in).Marshal()
	return resp
}

func MembershipIsNameValid(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipIsNameValidResponse{Error: &pb.RpcMembershipIsNameValidResponseError{Code: pb.RpcMembershipIsNameValidResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipIsNameValidRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipIsNameValidResponse{Error: &pb.RpcMembershipIsNameValidResponseError{Code: pb.RpcMembershipIsNameValidResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipIsNameValid(context.Background(), in).Marshal()
	return resp
}

func MembershipRegisterPaymentRequest(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipRegisterPaymentRequestResponse{Error: &pb.RpcMembershipRegisterPaymentRequestResponseError{Code: pb.RpcMembershipRegisterPaymentRequestResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipRegisterPaymentRequestRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipRegisterPaymentRequestResponse{Error: &pb.RpcMembershipRegisterPaymentRequestResponseError{Code: pb.RpcMembershipRegisterPaymentRequestResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipRegisterPaymentRequest(context.Background(), in).Marshal()
	return resp
}

func MembershipGetPortalLinkUrl(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipGetPortalLinkUrlResponse{Error: &pb.RpcMembershipGetPortalLinkUrlResponseError{Code: pb.RpcMembershipGetPortalLinkUrlResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipGetPortalLinkUrlRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipGetPortalLinkUrlResponse{Error: &pb.RpcMembershipGetPortalLinkUrlResponseError{Code: pb.RpcMembershipGetPortalLinkUrlResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipGetPortalLinkUrl(context.Background(), in).Marshal()
	return resp
}

func MembershipGetVerificationEmailStatus(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipGetVerificationEmailStatusResponse{Error: &pb.RpcMembershipGetVerificationEmailStatusResponseError{Code: pb.RpcMembershipGetVerificationEmailStatusResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipGetVerificationEmailStatusRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipGetVerificationEmailStatusResponse{Error: &pb.RpcMembershipGetVerificationEmailStatusResponseError{Code: pb.RpcMembershipGetVerificationEmailStatusResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipGetVerificationEmailStatus(context.Background(), in).Marshal()
	return resp
}

func MembershipGetVerificationEmail(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipGetVerificationEmailResponse{Error: &pb.RpcMembershipGetVerificationEmailResponseError{Code: pb.RpcMembershipGetVerificationEmailResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipGetVerificationEmailRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipGetVerificationEmailResponse{Error: &pb.RpcMembershipGetVerificationEmailResponseError{Code: pb.RpcMembershipGetVerificationEmailResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipGetVerificationEmail(context.Background(), in).Marshal()
	return resp
}

func MembershipVerifyEmailCode(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipVerifyEmailCodeResponse{Error: &pb.RpcMembershipVerifyEmailCodeResponseError{Code: pb.RpcMembershipVerifyEmailCodeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipVerifyEmailCodeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipVerifyEmailCodeResponse{Error: &pb.RpcMembershipVerifyEmailCodeResponseError{Code: pb.RpcMembershipVerifyEmailCodeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipVerifyEmailCode(context.Background(), in).Marshal()
	return resp
}

func MembershipFinalize(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipFinalizeResponse{Error: &pb.RpcMembershipFinalizeResponseError{Code: pb.RpcMembershipFinalizeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipFinalizeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipFinalizeResponse{Error: &pb.RpcMembershipFinalizeResponseError{Code: pb.RpcMembershipFinalizeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipFinalize(context.Background(), in).Marshal()
	return resp
}

func MembershipGetTiers(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipGetTiersResponse{Error: &pb.RpcMembershipGetTiersResponseError{Code: pb.RpcMembershipGetTiersResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipGetTiersRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipGetTiersResponse{Error: &pb.RpcMembershipGetTiersResponseError{Code: pb.RpcMembershipGetTiersResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipGetTiers(context.Background(), in).Marshal()
	return resp
}

func MembershipVerifyAppStoreReceipt(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipVerifyAppStoreReceiptResponse{Error: &pb.RpcMembershipVerifyAppStoreReceiptResponseError{Code: pb.RpcMembershipVerifyAppStoreReceiptResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipVerifyAppStoreReceiptRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipVerifyAppStoreReceiptResponse{Error: &pb.RpcMembershipVerifyAppStoreReceiptResponseError{Code: pb.RpcMembershipVerifyAppStoreReceiptResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipVerifyAppStoreReceipt(context.Background(), in).Marshal()
	return resp
}

func MembershipCodeGetInfo(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipCodeGetInfoResponse{Error: &pb.RpcMembershipCodeGetInfoResponseError{Code: pb.RpcMembershipCodeGetInfoResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipCodeGetInfoRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipCodeGetInfoResponse{Error: &pb.RpcMembershipCodeGetInfoResponseError{Code: pb.RpcMembershipCodeGetInfoResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipCodeGetInfo(context.Background(), in).Marshal()
	return resp
}

func MembershipCodeRedeem(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcMembershipCodeRedeemResponse{Error: &pb.RpcMembershipCodeRedeemResponseError{Code: pb.RpcMembershipCodeRedeemResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcMembershipCodeRedeemRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMembershipCodeRedeemResponse{Error: &pb.RpcMembershipCodeRedeemResponseError{Code: pb.RpcMembershipCodeRedeemResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MembershipCodeRedeem(context.Background(), in).Marshal()
	return resp
}

func NameServiceUserAccountGet(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcNameServiceUserAccountGetResponse{Error: &pb.RpcNameServiceUserAccountGetResponseError{Code: pb.RpcNameServiceUserAccountGetResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcNameServiceUserAccountGetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcNameServiceUserAccountGetResponse{Error: &pb.RpcNameServiceUserAccountGetResponseError{Code: pb.RpcNameServiceUserAccountGetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.NameServiceUserAccountGet(context.Background(), in).Marshal()
	return resp
}

func NameServiceResolveName(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcNameServiceResolveNameResponse{Error: &pb.RpcNameServiceResolveNameResponseError{Code: pb.RpcNameServiceResolveNameResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcNameServiceResolveNameRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcNameServiceResolveNameResponse{Error: &pb.RpcNameServiceResolveNameResponseError{Code: pb.RpcNameServiceResolveNameResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.NameServiceResolveName(context.Background(), in).Marshal()
	return resp
}

func NameServiceResolveAnyId(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcNameServiceResolveAnyIdResponse{Error: &pb.RpcNameServiceResolveAnyIdResponseError{Code: pb.RpcNameServiceResolveAnyIdResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcNameServiceResolveAnyIdRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcNameServiceResolveAnyIdResponse{Error: &pb.RpcNameServiceResolveAnyIdResponseError{Code: pb.RpcNameServiceResolveAnyIdResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.NameServiceResolveAnyId(context.Background(), in).Marshal()
	return resp
}

func BroadcastPayloadEvent(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcBroadcastPayloadEventResponse{Error: &pb.RpcBroadcastPayloadEventResponseError{Code: pb.RpcBroadcastPayloadEventResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcBroadcastPayloadEventRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBroadcastPayloadEventResponse{Error: &pb.RpcBroadcastPayloadEventResponseError{Code: pb.RpcBroadcastPayloadEventResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BroadcastPayloadEvent(context.Background(), in).Marshal()
	return resp
}

func DeviceSetName(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDeviceSetNameResponse{Error: &pb.RpcDeviceSetNameResponseError{Code: pb.RpcDeviceSetNameResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDeviceSetNameRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDeviceSetNameResponse{Error: &pb.RpcDeviceSetNameResponseError{Code: pb.RpcDeviceSetNameResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DeviceSetName(context.Background(), in).Marshal()
	return resp
}

func DeviceList(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDeviceListResponse{Error: &pb.RpcDeviceListResponseError{Code: pb.RpcDeviceListResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDeviceListRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDeviceListResponse{Error: &pb.RpcDeviceListResponseError{Code: pb.RpcDeviceListResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DeviceList(context.Background(), in).Marshal()
	return resp
}

func DeviceNetworkStateSet(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcDeviceNetworkStateSetResponse{Error: &pb.RpcDeviceNetworkStateSetResponseError{Code: pb.RpcDeviceNetworkStateSetResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcDeviceNetworkStateSetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDeviceNetworkStateSetResponse{Error: &pb.RpcDeviceNetworkStateSetResponseError{Code: pb.RpcDeviceNetworkStateSetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DeviceNetworkStateSet(context.Background(), in).Marshal()
	return resp
}

func ChatAddMessage(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatAddMessageResponse{Error: &pb.RpcChatAddMessageResponseError{Code: pb.RpcChatAddMessageResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatAddMessageRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatAddMessageResponse{Error: &pb.RpcChatAddMessageResponseError{Code: pb.RpcChatAddMessageResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatAddMessage(context.Background(), in).Marshal()
	return resp
}

func ChatEditMessageContent(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatEditMessageContentResponse{Error: &pb.RpcChatEditMessageContentResponseError{Code: pb.RpcChatEditMessageContentResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatEditMessageContentRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatEditMessageContentResponse{Error: &pb.RpcChatEditMessageContentResponseError{Code: pb.RpcChatEditMessageContentResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatEditMessageContent(context.Background(), in).Marshal()
	return resp
}

func ChatToggleMessageReaction(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatToggleMessageReactionResponse{Error: &pb.RpcChatToggleMessageReactionResponseError{Code: pb.RpcChatToggleMessageReactionResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatToggleMessageReactionRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatToggleMessageReactionResponse{Error: &pb.RpcChatToggleMessageReactionResponseError{Code: pb.RpcChatToggleMessageReactionResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatToggleMessageReaction(context.Background(), in).Marshal()
	return resp
}

func ChatDeleteMessage(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatDeleteMessageResponse{Error: &pb.RpcChatDeleteMessageResponseError{Code: pb.RpcChatDeleteMessageResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatDeleteMessageRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatDeleteMessageResponse{Error: &pb.RpcChatDeleteMessageResponseError{Code: pb.RpcChatDeleteMessageResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatDeleteMessage(context.Background(), in).Marshal()
	return resp
}

func ChatGetMessages(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatGetMessagesResponse{Error: &pb.RpcChatGetMessagesResponseError{Code: pb.RpcChatGetMessagesResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatGetMessagesRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatGetMessagesResponse{Error: &pb.RpcChatGetMessagesResponseError{Code: pb.RpcChatGetMessagesResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatGetMessages(context.Background(), in).Marshal()
	return resp
}

func ChatGetMessagesByIds(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatGetMessagesByIdsResponse{Error: &pb.RpcChatGetMessagesByIdsResponseError{Code: pb.RpcChatGetMessagesByIdsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatGetMessagesByIdsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatGetMessagesByIdsResponse{Error: &pb.RpcChatGetMessagesByIdsResponseError{Code: pb.RpcChatGetMessagesByIdsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatGetMessagesByIds(context.Background(), in).Marshal()
	return resp
}

func ChatSubscribeLastMessages(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatSubscribeLastMessagesResponse{Error: &pb.RpcChatSubscribeLastMessagesResponseError{Code: pb.RpcChatSubscribeLastMessagesResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatSubscribeLastMessagesRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatSubscribeLastMessagesResponse{Error: &pb.RpcChatSubscribeLastMessagesResponseError{Code: pb.RpcChatSubscribeLastMessagesResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatSubscribeLastMessages(context.Background(), in).Marshal()
	return resp
}

func ChatUnsubscribe(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatUnsubscribeResponse{Error: &pb.RpcChatUnsubscribeResponseError{Code: pb.RpcChatUnsubscribeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatUnsubscribeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatUnsubscribeResponse{Error: &pb.RpcChatUnsubscribeResponseError{Code: pb.RpcChatUnsubscribeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatUnsubscribe(context.Background(), in).Marshal()
	return resp
}

func ChatReadMessages(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatReadMessagesResponse{Error: &pb.RpcChatReadMessagesResponseError{Code: pb.RpcChatReadMessagesResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatReadMessagesRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatReadMessagesResponse{Error: &pb.RpcChatReadMessagesResponseError{Code: pb.RpcChatReadMessagesResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatReadMessages(context.Background(), in).Marshal()
	return resp
}

func ChatUnreadMessages(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatUnreadResponse{Error: &pb.RpcChatUnreadResponseError{Code: pb.RpcChatUnreadResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatUnreadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatUnreadResponse{Error: &pb.RpcChatUnreadResponseError{Code: pb.RpcChatUnreadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatUnreadMessages(context.Background(), in).Marshal()
	return resp
}

func ChatSubscribeToMessagePreviews(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatSubscribeToMessagePreviewsResponse{Error: &pb.RpcChatSubscribeToMessagePreviewsResponseError{Code: pb.RpcChatSubscribeToMessagePreviewsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatSubscribeToMessagePreviewsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatSubscribeToMessagePreviewsResponse{Error: &pb.RpcChatSubscribeToMessagePreviewsResponseError{Code: pb.RpcChatSubscribeToMessagePreviewsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatSubscribeToMessagePreviews(context.Background(), in).Marshal()
	return resp
}

func ChatUnsubscribeFromMessagePreviews(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatUnsubscribeFromMessagePreviewsResponse{Error: &pb.RpcChatUnsubscribeFromMessagePreviewsResponseError{Code: pb.RpcChatUnsubscribeFromMessagePreviewsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatUnsubscribeFromMessagePreviewsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatUnsubscribeFromMessagePreviewsResponse{Error: &pb.RpcChatUnsubscribeFromMessagePreviewsResponseError{Code: pb.RpcChatUnsubscribeFromMessagePreviewsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatUnsubscribeFromMessagePreviews(context.Background(), in).Marshal()
	return resp
}

func ObjectChatAdd(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcObjectChatAddResponse{Error: &pb.RpcObjectChatAddResponseError{Code: pb.RpcObjectChatAddResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcObjectChatAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectChatAddResponse{Error: &pb.RpcObjectChatAddResponseError{Code: pb.RpcObjectChatAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectChatAdd(context.Background(), in).Marshal()
	return resp
}

func ChatReadAll(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcChatReadAllResponse{Error: &pb.RpcChatReadAllResponseError{Code: pb.RpcChatReadAllResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcChatReadAllRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcChatReadAllResponse{Error: &pb.RpcChatReadAllResponseError{Code: pb.RpcChatReadAllResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ChatReadAll(context.Background(), in).Marshal()
	return resp
}

func AIWritingTools(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAIWritingToolsResponse{Error: &pb.RpcAIWritingToolsResponseError{Code: pb.RpcAIWritingToolsResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAIWritingToolsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAIWritingToolsResponse{Error: &pb.RpcAIWritingToolsResponseError{Code: pb.RpcAIWritingToolsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AIWritingTools(context.Background(), in).Marshal()
	return resp
}

func AIAutofill(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAIAutofillResponse{Error: &pb.RpcAIAutofillResponseError{Code: pb.RpcAIAutofillResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAIAutofillRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAIAutofillResponse{Error: &pb.RpcAIAutofillResponseError{Code: pb.RpcAIAutofillResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AIAutofill(context.Background(), in).Marshal()
	return resp
}

func AIListSummary(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAIListSummaryResponse{Error: &pb.RpcAIListSummaryResponseError{Code: pb.RpcAIListSummaryResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAIListSummaryRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAIListSummaryResponse{Error: &pb.RpcAIListSummaryResponseError{Code: pb.RpcAIListSummaryResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AIListSummary(context.Background(), in).Marshal()
	return resp
}

func AIObjectCreateFromUrl(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcAIObjectCreateFromUrlResponse{Error: &pb.RpcAIObjectCreateFromUrlResponseError{Code: pb.RpcAIObjectCreateFromUrlResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcAIObjectCreateFromUrlRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcAIObjectCreateFromUrlResponse{Error: &pb.RpcAIObjectCreateFromUrlResponseError{Code: pb.RpcAIObjectCreateFromUrlResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.AIObjectCreateFromUrl(context.Background(), in).Marshal()
	return resp
}

func PushNotificationRegisterToken(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcPushNotificationRegisterTokenResponse{Error: &pb.RpcPushNotificationRegisterTokenResponseError{Code: pb.RpcPushNotificationRegisterTokenResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcPushNotificationRegisterTokenRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcPushNotificationRegisterTokenResponse{Error: &pb.RpcPushNotificationRegisterTokenResponseError{Code: pb.RpcPushNotificationRegisterTokenResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.PushNotificationRegisterToken(context.Background(), in).Marshal()
	return resp
}

func PushNotificationSetSpaceMode(b []byte) (resp []byte) {
	defer func() {
		if PanicHandler != nil {
			if r := recover(); r != nil {
				resp, _ = (&pb.RpcPushNotificationSetSpaceModeResponse{Error: &pb.RpcPushNotificationSetSpaceModeResponseError{Code: pb.RpcPushNotificationSetSpaceModeResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
				PanicHandler(r)
			}
		}
	}()

	in := new(pb.RpcPushNotificationSetSpaceModeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcPushNotificationSetSpaceModeResponse{Error: &pb.RpcPushNotificationSetSpaceModeResponseError{Code: pb.RpcPushNotificationSetSpaceModeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.PushNotificationSetSpaceMode(context.Background(), in).Marshal()
	return resp
}

var PanicHandler func(v interface{})

func CommandAsync(cmd string, data []byte, callback func(data []byte)) {
	go func() {
		var cd []byte
		switch cmd {
		case "AppGetVersion":
			cd = AppGetVersion(data)
		case "AppSetDeviceState":
			cd = AppSetDeviceState(data)
		case "AppShutdown":
			cd = AppShutdown(data)
		case "WalletCreate":
			cd = WalletCreate(data)
		case "WalletRecover":
			cd = WalletRecover(data)
		case "WalletConvert":
			cd = WalletConvert(data)
		case "AccountLocalLinkNewChallenge":
			cd = AccountLocalLinkNewChallenge(data)
		case "AccountLocalLinkSolveChallenge":
			cd = AccountLocalLinkSolveChallenge(data)
		case "AccountLocalLinkCreateApp":
			cd = AccountLocalLinkCreateApp(data)
		case "AccountLocalLinkListApps":
			cd = AccountLocalLinkListApps(data)
		case "AccountLocalLinkRevokeApp":
			cd = AccountLocalLinkRevokeApp(data)
		case "WalletCreateSession":
			cd = WalletCreateSession(data)
		case "WalletCloseSession":
			cd = WalletCloseSession(data)
		case "WorkspaceCreate":
			cd = WorkspaceCreate(data)
		case "WorkspaceOpen":
			cd = WorkspaceOpen(data)
		case "WorkspaceObjectAdd":
			cd = WorkspaceObjectAdd(data)
		case "WorkspaceObjectListAdd":
			cd = WorkspaceObjectListAdd(data)
		case "WorkspaceObjectListRemove":
			cd = WorkspaceObjectListRemove(data)
		case "WorkspaceSelect":
			cd = WorkspaceSelect(data)
		case "WorkspaceGetCurrent":
			cd = WorkspaceGetCurrent(data)
		case "WorkspaceGetAll":
			cd = WorkspaceGetAll(data)
		case "WorkspaceSetInfo":
			cd = WorkspaceSetInfo(data)
		case "WorkspaceExport":
			cd = WorkspaceExport(data)
		case "AccountRecover":
			cd = AccountRecover(data)
		case "AccountMigrate":
			cd = AccountMigrate(data)
		case "AccountMigrateCancel":
			cd = AccountMigrateCancel(data)
		case "AccountCreate":
			cd = AccountCreate(data)
		case "AccountDelete":
			cd = AccountDelete(data)
		case "AccountRevertDeletion":
			cd = AccountRevertDeletion(data)
		case "AccountSelect":
			cd = AccountSelect(data)
		case "AccountEnableLocalNetworkSync":
			cd = AccountEnableLocalNetworkSync(data)
		case "AccountChangeJsonApiAddr":
			cd = AccountChangeJsonApiAddr(data)
		case "AccountStop":
			cd = AccountStop(data)
		case "AccountMove":
			cd = AccountMove(data)
		case "AccountConfigUpdate":
			cd = AccountConfigUpdate(data)
		case "AccountRecoverFromLegacyExport":
			cd = AccountRecoverFromLegacyExport(data)
		case "AccountChangeNetworkConfigAndRestart":
			cd = AccountChangeNetworkConfigAndRestart(data)
		case "SpaceDelete":
			cd = SpaceDelete(data)
		case "SpaceInviteGenerate":
			cd = SpaceInviteGenerate(data)
		case "SpaceInviteChange":
			cd = SpaceInviteChange(data)
		case "SpaceInviteGetCurrent":
			cd = SpaceInviteGetCurrent(data)
		case "SpaceInviteGetGuest":
			cd = SpaceInviteGetGuest(data)
		case "SpaceInviteRevoke":
			cd = SpaceInviteRevoke(data)
		case "SpaceInviteView":
			cd = SpaceInviteView(data)
		case "SpaceJoin":
			cd = SpaceJoin(data)
		case "SpaceJoinCancel":
			cd = SpaceJoinCancel(data)
		case "SpaceStopSharing":
			cd = SpaceStopSharing(data)
		case "SpaceRequestApprove":
			cd = SpaceRequestApprove(data)
		case "SpaceRequestDecline":
			cd = SpaceRequestDecline(data)
		case "SpaceLeaveApprove":
			cd = SpaceLeaveApprove(data)
		case "SpaceMakeShareable":
			cd = SpaceMakeShareable(data)
		case "SpaceParticipantRemove":
			cd = SpaceParticipantRemove(data)
		case "SpaceParticipantPermissionsChange":
			cd = SpaceParticipantPermissionsChange(data)
		case "SpaceSetOrder":
			cd = SpaceSetOrder(data)
		case "SpaceUnsetOrder":
			cd = SpaceUnsetOrder(data)
		case "PublishingCreate":
			cd = PublishingCreate(data)
		case "PublishingRemove":
			cd = PublishingRemove(data)
		case "PublishingList":
			cd = PublishingList(data)
		case "PublishingResolveUri":
			cd = PublishingResolveUri(data)
		case "PublishingGetStatus":
			cd = PublishingGetStatus(data)
		case "ObjectOpen":
			cd = ObjectOpen(data)
		case "ObjectRefresh":
			cd = ObjectRefresh(data)
		case "ObjectClose":
			cd = ObjectClose(data)
		case "ObjectShow":
			cd = ObjectShow(data)
		case "ObjectCreate":
			cd = ObjectCreate(data)
		case "ObjectCreateBookmark":
			cd = ObjectCreateBookmark(data)
		case "ObjectCreateFromUrl":
			cd = ObjectCreateFromUrl(data)
		case "ObjectCreateSet":
			cd = ObjectCreateSet(data)
		case "ObjectGraph":
			cd = ObjectGraph(data)
		case "ObjectSearch":
			cd = ObjectSearch(data)
		case "ObjectSearchWithMeta":
			cd = ObjectSearchWithMeta(data)
		case "ObjectSearchSubscribe":
			cd = ObjectSearchSubscribe(data)
		case "ObjectCrossSpaceSearchSubscribe":
			cd = ObjectCrossSpaceSearchSubscribe(data)
		case "ObjectCrossSpaceSearchUnsubscribe":
			cd = ObjectCrossSpaceSearchUnsubscribe(data)
		case "ObjectSubscribeIds":
			cd = ObjectSubscribeIds(data)
		case "ObjectGroupsSubscribe":
			cd = ObjectGroupsSubscribe(data)
		case "ObjectSearchUnsubscribe":
			cd = ObjectSearchUnsubscribe(data)
		case "ObjectSetDetails":
			cd = ObjectSetDetails(data)
		case "ObjectDuplicate":
			cd = ObjectDuplicate(data)
		case "ObjectSetObjectType":
			cd = ObjectSetObjectType(data)
		case "ObjectSetLayout":
			cd = ObjectSetLayout(data)
		case "ObjectSetInternalFlags":
			cd = ObjectSetInternalFlags(data)
		case "ObjectSetIsFavorite":
			cd = ObjectSetIsFavorite(data)
		case "ObjectSetIsArchived":
			cd = ObjectSetIsArchived(data)
		case "ObjectSetSource":
			cd = ObjectSetSource(data)
		case "ObjectWorkspaceSetDashboard":
			cd = ObjectWorkspaceSetDashboard(data)
		case "ObjectListDuplicate":
			cd = ObjectListDuplicate(data)
		case "ObjectListDelete":
			cd = ObjectListDelete(data)
		case "ObjectListSetIsArchived":
			cd = ObjectListSetIsArchived(data)
		case "ObjectListSetIsFavorite":
			cd = ObjectListSetIsFavorite(data)
		case "ObjectListSetObjectType":
			cd = ObjectListSetObjectType(data)
		case "ObjectListSetDetails":
			cd = ObjectListSetDetails(data)
		case "ObjectListModifyDetailValues":
			cd = ObjectListModifyDetailValues(data)
		case "ObjectApplyTemplate":
			cd = ObjectApplyTemplate(data)
		case "ObjectToSet":
			cd = ObjectToSet(data)
		case "ObjectToCollection":
			cd = ObjectToCollection(data)
		case "ObjectShareByLink":
			cd = ObjectShareByLink(data)
		case "ObjectUndo":
			cd = ObjectUndo(data)
		case "ObjectRedo":
			cd = ObjectRedo(data)
		case "ObjectListExport":
			cd = ObjectListExport(data)
		case "ObjectExport":
			cd = ObjectExport(data)
		case "ObjectBookmarkFetch":
			cd = ObjectBookmarkFetch(data)
		case "ObjectImport":
			cd = ObjectImport(data)
		case "ObjectImportList":
			cd = ObjectImportList(data)
		case "ObjectImportNotionValidateToken":
			cd = ObjectImportNotionValidateToken(data)
		case "ObjectImportUseCase":
			cd = ObjectImportUseCase(data)
		case "ObjectImportExperience":
			cd = ObjectImportExperience(data)
		case "ObjectDateByTimestamp":
			cd = ObjectDateByTimestamp(data)
		case "ObjectCollectionAdd":
			cd = ObjectCollectionAdd(data)
		case "ObjectCollectionRemove":
			cd = ObjectCollectionRemove(data)
		case "ObjectCollectionSort":
			cd = ObjectCollectionSort(data)
		case "ObjectCreateRelation":
			cd = ObjectCreateRelation(data)
		case "ObjectCreateRelationOption":
			cd = ObjectCreateRelationOption(data)
		case "RelationListRemoveOption":
			cd = RelationListRemoveOption(data)
		case "RelationOptions":
			cd = RelationOptions(data)
		case "RelationOptionSetOrder":
			cd = RelationOptionSetOrder(data)
		case "RelationListWithValue":
			cd = RelationListWithValue(data)
		case "ObjectRelationAdd":
			cd = ObjectRelationAdd(data)
		case "ObjectRelationDelete":
			cd = ObjectRelationDelete(data)
		case "ObjectRelationAddFeatured":
			cd = ObjectRelationAddFeatured(data)
		case "ObjectRelationRemoveFeatured":
			cd = ObjectRelationRemoveFeatured(data)
		case "ObjectRelationListAvailable":
			cd = ObjectRelationListAvailable(data)
		case "ObjectCreateObjectType":
			cd = ObjectCreateObjectType(data)
		case "ObjectTypeRelationAdd":
			cd = ObjectTypeRelationAdd(data)
		case "ObjectTypeRelationRemove":
			cd = ObjectTypeRelationRemove(data)
		case "ObjectTypeRecommendedRelationsSet":
			cd = ObjectTypeRecommendedRelationsSet(data)
		case "ObjectTypeRecommendedFeaturedRelationsSet":
			cd = ObjectTypeRecommendedFeaturedRelationsSet(data)
		case "ObjectTypeListConflictingRelations":
			cd = ObjectTypeListConflictingRelations(data)
		case "ObjectTypeResolveLayoutConflicts":
			cd = ObjectTypeResolveLayoutConflicts(data)
		case "ObjectTypeSetOrder":
			cd = ObjectTypeSetOrder(data)
		case "HistoryShowVersion":
			cd = HistoryShowVersion(data)
		case "HistoryGetVersions":
			cd = HistoryGetVersions(data)
		case "HistorySetVersion":
			cd = HistorySetVersion(data)
		case "HistoryDiffVersions":
			cd = HistoryDiffVersions(data)
		case "FileSpaceOffload":
			cd = FileSpaceOffload(data)
		case "FileReconcile":
			cd = FileReconcile(data)
		case "FileListOffload":
			cd = FileListOffload(data)
		case "FileUpload":
			cd = FileUpload(data)
		case "FileDownload":
			cd = FileDownload(data)
		case "FileDiscardPreload":
			cd = FileDiscardPreload(data)
		case "FileDrop":
			cd = FileDrop(data)
		case "FileSpaceUsage":
			cd = FileSpaceUsage(data)
		case "FileNodeUsage":
			cd = FileNodeUsage(data)
		case "NavigationListObjects":
			cd = NavigationListObjects(data)
		case "NavigationGetObjectInfoWithLinks":
			cd = NavigationGetObjectInfoWithLinks(data)
		case "TemplateCreateFromObject":
			cd = TemplateCreateFromObject(data)
		case "TemplateClone":
			cd = TemplateClone(data)
		case "TemplateExportAll":
			cd = TemplateExportAll(data)
		case "LinkPreview":
			cd = LinkPreview(data)
		case "UnsplashSearch":
			cd = UnsplashSearch(data)
		case "UnsplashDownload":
			cd = UnsplashDownload(data)
		case "GalleryDownloadManifest":
			cd = GalleryDownloadManifest(data)
		case "GalleryDownloadIndex":
			cd = GalleryDownloadIndex(data)
		case "BlockUpload":
			cd = BlockUpload(data)
		case "BlockReplace":
			cd = BlockReplace(data)
		case "BlockCreate":
			cd = BlockCreate(data)
		case "BlockSplit":
			cd = BlockSplit(data)
		case "BlockMerge":
			cd = BlockMerge(data)
		case "BlockCopy":
			cd = BlockCopy(data)
		case "BlockPaste":
			cd = BlockPaste(data)
		case "BlockCut":
			cd = BlockCut(data)
		case "BlockSetFields":
			cd = BlockSetFields(data)
		case "BlockExport":
			cd = BlockExport(data)
		case "BlockSetCarriage":
			cd = BlockSetCarriage(data)
		case "BlockPreview":
			cd = BlockPreview(data)
		case "BlockListDelete":
			cd = BlockListDelete(data)
		case "BlockListMoveToExistingObject":
			cd = BlockListMoveToExistingObject(data)
		case "BlockListMoveToNewObject":
			cd = BlockListMoveToNewObject(data)
		case "BlockListConvertToObjects":
			cd = BlockListConvertToObjects(data)
		case "BlockListSetFields":
			cd = BlockListSetFields(data)
		case "BlockListDuplicate":
			cd = BlockListDuplicate(data)
		case "BlockListSetBackgroundColor":
			cd = BlockListSetBackgroundColor(data)
		case "BlockListSetAlign":
			cd = BlockListSetAlign(data)
		case "BlockListSetVerticalAlign":
			cd = BlockListSetVerticalAlign(data)
		case "BlockListTurnInto":
			cd = BlockListTurnInto(data)
		case "BlockTextSetText":
			cd = BlockTextSetText(data)
		case "BlockTextSetColor":
			cd = BlockTextSetColor(data)
		case "BlockTextSetStyle":
			cd = BlockTextSetStyle(data)
		case "BlockTextSetChecked":
			cd = BlockTextSetChecked(data)
		case "BlockTextSetIcon":
			cd = BlockTextSetIcon(data)
		case "BlockTextListSetColor":
			cd = BlockTextListSetColor(data)
		case "BlockTextListSetMark":
			cd = BlockTextListSetMark(data)
		case "BlockTextListSetStyle":
			cd = BlockTextListSetStyle(data)
		case "BlockTextListClearStyle":
			cd = BlockTextListClearStyle(data)
		case "BlockTextListClearContent":
			cd = BlockTextListClearContent(data)
		case "BlockFileSetName":
			cd = BlockFileSetName(data)
		case "BlockFileSetTargetObjectId":
			cd = BlockFileSetTargetObjectId(data)
		case "BlockImageSetName":
			cd = BlockImageSetName(data)
		case "BlockVideoSetName":
			cd = BlockVideoSetName(data)
		case "BlockFileCreateAndUpload":
			cd = BlockFileCreateAndUpload(data)
		case "BlockFileListSetStyle":
			cd = BlockFileListSetStyle(data)
		case "BlockDataviewViewCreate":
			cd = BlockDataviewViewCreate(data)
		case "BlockDataviewViewDelete":
			cd = BlockDataviewViewDelete(data)
		case "BlockDataviewViewUpdate":
			cd = BlockDataviewViewUpdate(data)
		case "BlockDataviewViewSetActive":
			cd = BlockDataviewViewSetActive(data)
		case "BlockDataviewViewSetPosition":
			cd = BlockDataviewViewSetPosition(data)
		case "BlockDataviewSetSource":
			cd = BlockDataviewSetSource(data)
		case "BlockDataviewRelationSet":
			cd = BlockDataviewRelationSet(data)
		case "BlockDataviewRelationAdd":
			cd = BlockDataviewRelationAdd(data)
		case "BlockDataviewRelationDelete":
			cd = BlockDataviewRelationDelete(data)
		case "BlockDataviewGroupOrderUpdate":
			cd = BlockDataviewGroupOrderUpdate(data)
		case "BlockDataviewObjectOrderUpdate":
			cd = BlockDataviewObjectOrderUpdate(data)
		case "BlockDataviewObjectOrderMove":
			cd = BlockDataviewObjectOrderMove(data)
		case "BlockDataviewCreateFromExistingObject":
			cd = BlockDataviewCreateFromExistingObject(data)
		case "BlockDataviewFilterAdd":
			cd = BlockDataviewFilterAdd(data)
		case "BlockDataviewFilterRemove":
			cd = BlockDataviewFilterRemove(data)
		case "BlockDataviewFilterReplace":
			cd = BlockDataviewFilterReplace(data)
		case "BlockDataviewFilterSort":
			cd = BlockDataviewFilterSort(data)
		case "BlockDataviewSortAdd":
			cd = BlockDataviewSortAdd(data)
		case "BlockDataviewSortRemove":
			cd = BlockDataviewSortRemove(data)
		case "BlockDataviewSortReplace":
			cd = BlockDataviewSortReplace(data)
		case "BlockDataviewSortSort":
			cd = BlockDataviewSortSort(data)
		case "BlockDataviewViewRelationAdd":
			cd = BlockDataviewViewRelationAdd(data)
		case "BlockDataviewViewRelationRemove":
			cd = BlockDataviewViewRelationRemove(data)
		case "BlockDataviewViewRelationReplace":
			cd = BlockDataviewViewRelationReplace(data)
		case "BlockDataviewViewRelationSort":
			cd = BlockDataviewViewRelationSort(data)
		case "BlockTableCreate":
			cd = BlockTableCreate(data)
		case "BlockTableExpand":
			cd = BlockTableExpand(data)
		case "BlockTableRowCreate":
			cd = BlockTableRowCreate(data)
		case "BlockTableRowDelete":
			cd = BlockTableRowDelete(data)
		case "BlockTableRowDuplicate":
			cd = BlockTableRowDuplicate(data)
		case "BlockTableRowSetHeader":
			cd = BlockTableRowSetHeader(data)
		case "BlockTableColumnCreate":
			cd = BlockTableColumnCreate(data)
		case "BlockTableColumnMove":
			cd = BlockTableColumnMove(data)
		case "BlockTableColumnDelete":
			cd = BlockTableColumnDelete(data)
		case "BlockTableColumnDuplicate":
			cd = BlockTableColumnDuplicate(data)
		case "BlockTableRowListFill":
			cd = BlockTableRowListFill(data)
		case "BlockTableRowListClean":
			cd = BlockTableRowListClean(data)
		case "BlockTableColumnListFill":
			cd = BlockTableColumnListFill(data)
		case "BlockTableSort":
			cd = BlockTableSort(data)
		case "BlockCreateWidget":
			cd = BlockCreateWidget(data)
		case "BlockWidgetSetTargetId":
			cd = BlockWidgetSetTargetId(data)
		case "BlockWidgetSetLayout":
			cd = BlockWidgetSetLayout(data)
		case "BlockWidgetSetLimit":
			cd = BlockWidgetSetLimit(data)
		case "BlockWidgetSetViewId":
			cd = BlockWidgetSetViewId(data)
		case "BlockLinkCreateWithObject":
			cd = BlockLinkCreateWithObject(data)
		case "BlockLinkListSetAppearance":
			cd = BlockLinkListSetAppearance(data)
		case "BlockBookmarkFetch":
			cd = BlockBookmarkFetch(data)
		case "BlockBookmarkCreateAndFetch":
			cd = BlockBookmarkCreateAndFetch(data)
		case "BlockRelationSetKey":
			cd = BlockRelationSetKey(data)
		case "BlockRelationAdd":
			cd = BlockRelationAdd(data)
		case "BlockDivListSetStyle":
			cd = BlockDivListSetStyle(data)
		case "BlockLatexSetText":
			cd = BlockLatexSetText(data)
		case "ProcessCancel":
			cd = ProcessCancel(data)
		case "ProcessSubscribe":
			cd = ProcessSubscribe(data)
		case "ProcessUnsubscribe":
			cd = ProcessUnsubscribe(data)
		case "LogSend":
			cd = LogSend(data)
		case "DebugStat":
			cd = DebugStat(data)
		case "DebugTree":
			cd = DebugTree(data)
		case "DebugTreeHeads":
			cd = DebugTreeHeads(data)
		case "DebugSpaceSummary":
			cd = DebugSpaceSummary(data)
		case "DebugStackGoroutines":
			cd = DebugStackGoroutines(data)
		case "DebugExportLocalstore":
			cd = DebugExportLocalstore(data)
		case "DebugPing":
			cd = DebugPing(data)
		case "DebugSubscriptions":
			cd = DebugSubscriptions(data)
		case "DebugOpenedObjects":
			cd = DebugOpenedObjects(data)
		case "DebugRunProfiler":
			cd = DebugRunProfiler(data)
		case "DebugAccountSelectTrace":
			cd = DebugAccountSelectTrace(data)
		case "DebugAnystoreObjectChanges":
			cd = DebugAnystoreObjectChanges(data)
		case "DebugNetCheck":
			cd = DebugNetCheck(data)
		case "DebugExportLog":
			cd = DebugExportLog(data)
		case "InitialSetParameters":
			cd = InitialSetParameters(data)
		case "NotificationList":
			cd = NotificationList(data)
		case "NotificationReply":
			cd = NotificationReply(data)
		case "NotificationTest":
			cd = NotificationTest(data)
		case "MembershipGetStatus":
			cd = MembershipGetStatus(data)
		case "MembershipIsNameValid":
			cd = MembershipIsNameValid(data)
		case "MembershipRegisterPaymentRequest":
			cd = MembershipRegisterPaymentRequest(data)
		case "MembershipGetPortalLinkUrl":
			cd = MembershipGetPortalLinkUrl(data)
		case "MembershipGetVerificationEmailStatus":
			cd = MembershipGetVerificationEmailStatus(data)
		case "MembershipGetVerificationEmail":
			cd = MembershipGetVerificationEmail(data)
		case "MembershipVerifyEmailCode":
			cd = MembershipVerifyEmailCode(data)
		case "MembershipFinalize":
			cd = MembershipFinalize(data)
		case "MembershipGetTiers":
			cd = MembershipGetTiers(data)
		case "MembershipVerifyAppStoreReceipt":
			cd = MembershipVerifyAppStoreReceipt(data)
		case "MembershipCodeGetInfo":
			cd = MembershipCodeGetInfo(data)
		case "MembershipCodeRedeem":
			cd = MembershipCodeRedeem(data)
		case "NameServiceUserAccountGet":
			cd = NameServiceUserAccountGet(data)
		case "NameServiceResolveName":
			cd = NameServiceResolveName(data)
		case "NameServiceResolveAnyId":
			cd = NameServiceResolveAnyId(data)
		case "BroadcastPayloadEvent":
			cd = BroadcastPayloadEvent(data)
		case "DeviceSetName":
			cd = DeviceSetName(data)
		case "DeviceList":
			cd = DeviceList(data)
		case "DeviceNetworkStateSet":
			cd = DeviceNetworkStateSet(data)
		case "ChatAddMessage":
			cd = ChatAddMessage(data)
		case "ChatEditMessageContent":
			cd = ChatEditMessageContent(data)
		case "ChatToggleMessageReaction":
			cd = ChatToggleMessageReaction(data)
		case "ChatDeleteMessage":
			cd = ChatDeleteMessage(data)
		case "ChatGetMessages":
			cd = ChatGetMessages(data)
		case "ChatGetMessagesByIds":
			cd = ChatGetMessagesByIds(data)
		case "ChatSubscribeLastMessages":
			cd = ChatSubscribeLastMessages(data)
		case "ChatUnsubscribe":
			cd = ChatUnsubscribe(data)
		case "ChatReadMessages":
			cd = ChatReadMessages(data)
		case "ChatUnreadMessages":
			cd = ChatUnreadMessages(data)
		case "ChatSubscribeToMessagePreviews":
			cd = ChatSubscribeToMessagePreviews(data)
		case "ChatUnsubscribeFromMessagePreviews":
			cd = ChatUnsubscribeFromMessagePreviews(data)
		case "ObjectChatAdd":
			cd = ObjectChatAdd(data)
		case "ChatReadAll":
			cd = ChatReadAll(data)
		case "AIWritingTools":
			cd = AIWritingTools(data)
		case "AIAutofill":
			cd = AIAutofill(data)
		case "AIListSummary":
			cd = AIListSummary(data)
		case "AIObjectCreateFromUrl":
			cd = AIObjectCreateFromUrl(data)
		case "PushNotificationRegisterToken":
			cd = PushNotificationRegisterToken(data)
		case "PushNotificationSetSpaceMode":
			cd = PushNotificationSetSpaceMode(data)
		default:
			log.Errorf("unknown command type: %s\n", cmd)
		}
		if callback != nil {
			callback(cd)
		}
	}()
}

type MessageHandler interface {
	Handle(b []byte)
}

func CommandMobile(cmd string, data []byte, callback MessageHandler) {
	CommandAsync(cmd, data, callback.Handle)
}

type ClientCommandsHandlerProxy struct {
	client       ClientCommandsHandler
	interceptors []func(ctx context.Context, req any, methodName string, actualCall func(ctx context.Context, req any) (any, error)) (any, error)
}

func (h *ClientCommandsHandlerProxy) AppGetVersion(ctx context.Context, req *pb.RpcAppGetVersionRequest) *pb.RpcAppGetVersionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AppGetVersion(ctx, req.(*pb.RpcAppGetVersionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AppGetVersion", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAppGetVersionResponse)
}
func (h *ClientCommandsHandlerProxy) AppSetDeviceState(ctx context.Context, req *pb.RpcAppSetDeviceStateRequest) *pb.RpcAppSetDeviceStateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AppSetDeviceState(ctx, req.(*pb.RpcAppSetDeviceStateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AppSetDeviceState", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAppSetDeviceStateResponse)
}
func (h *ClientCommandsHandlerProxy) AppShutdown(ctx context.Context, req *pb.RpcAppShutdownRequest) *pb.RpcAppShutdownResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AppShutdown(ctx, req.(*pb.RpcAppShutdownRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AppShutdown", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAppShutdownResponse)
}
func (h *ClientCommandsHandlerProxy) WalletCreate(ctx context.Context, req *pb.RpcWalletCreateRequest) *pb.RpcWalletCreateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WalletCreate(ctx, req.(*pb.RpcWalletCreateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WalletCreate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWalletCreateResponse)
}
func (h *ClientCommandsHandlerProxy) WalletRecover(ctx context.Context, req *pb.RpcWalletRecoverRequest) *pb.RpcWalletRecoverResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WalletRecover(ctx, req.(*pb.RpcWalletRecoverRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WalletRecover", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWalletRecoverResponse)
}
func (h *ClientCommandsHandlerProxy) WalletConvert(ctx context.Context, req *pb.RpcWalletConvertRequest) *pb.RpcWalletConvertResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WalletConvert(ctx, req.(*pb.RpcWalletConvertRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WalletConvert", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWalletConvertResponse)
}
func (h *ClientCommandsHandlerProxy) AccountLocalLinkNewChallenge(ctx context.Context, req *pb.RpcAccountLocalLinkNewChallengeRequest) *pb.RpcAccountLocalLinkNewChallengeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountLocalLinkNewChallenge(ctx, req.(*pb.RpcAccountLocalLinkNewChallengeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountLocalLinkNewChallenge", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountLocalLinkNewChallengeResponse)
}
func (h *ClientCommandsHandlerProxy) AccountLocalLinkSolveChallenge(ctx context.Context, req *pb.RpcAccountLocalLinkSolveChallengeRequest) *pb.RpcAccountLocalLinkSolveChallengeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountLocalLinkSolveChallenge(ctx, req.(*pb.RpcAccountLocalLinkSolveChallengeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountLocalLinkSolveChallenge", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountLocalLinkSolveChallengeResponse)
}
func (h *ClientCommandsHandlerProxy) AccountLocalLinkCreateApp(ctx context.Context, req *pb.RpcAccountLocalLinkCreateAppRequest) *pb.RpcAccountLocalLinkCreateAppResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountLocalLinkCreateApp(ctx, req.(*pb.RpcAccountLocalLinkCreateAppRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountLocalLinkCreateApp", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountLocalLinkCreateAppResponse)
}
func (h *ClientCommandsHandlerProxy) AccountLocalLinkListApps(ctx context.Context, req *pb.RpcAccountLocalLinkListAppsRequest) *pb.RpcAccountLocalLinkListAppsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountLocalLinkListApps(ctx, req.(*pb.RpcAccountLocalLinkListAppsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountLocalLinkListApps", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountLocalLinkListAppsResponse)
}
func (h *ClientCommandsHandlerProxy) AccountLocalLinkRevokeApp(ctx context.Context, req *pb.RpcAccountLocalLinkRevokeAppRequest) *pb.RpcAccountLocalLinkRevokeAppResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountLocalLinkRevokeApp(ctx, req.(*pb.RpcAccountLocalLinkRevokeAppRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountLocalLinkRevokeApp", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountLocalLinkRevokeAppResponse)
}
func (h *ClientCommandsHandlerProxy) WalletCreateSession(ctx context.Context, req *pb.RpcWalletCreateSessionRequest) *pb.RpcWalletCreateSessionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WalletCreateSession(ctx, req.(*pb.RpcWalletCreateSessionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WalletCreateSession", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWalletCreateSessionResponse)
}
func (h *ClientCommandsHandlerProxy) WalletCloseSession(ctx context.Context, req *pb.RpcWalletCloseSessionRequest) *pb.RpcWalletCloseSessionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WalletCloseSession(ctx, req.(*pb.RpcWalletCloseSessionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WalletCloseSession", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWalletCloseSessionResponse)
}
func (h *ClientCommandsHandlerProxy) WorkspaceCreate(ctx context.Context, req *pb.RpcWorkspaceCreateRequest) *pb.RpcWorkspaceCreateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WorkspaceCreate(ctx, req.(*pb.RpcWorkspaceCreateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WorkspaceCreate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWorkspaceCreateResponse)
}
func (h *ClientCommandsHandlerProxy) WorkspaceOpen(ctx context.Context, req *pb.RpcWorkspaceOpenRequest) *pb.RpcWorkspaceOpenResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WorkspaceOpen(ctx, req.(*pb.RpcWorkspaceOpenRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WorkspaceOpen", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWorkspaceOpenResponse)
}
func (h *ClientCommandsHandlerProxy) WorkspaceObjectAdd(ctx context.Context, req *pb.RpcWorkspaceObjectAddRequest) *pb.RpcWorkspaceObjectAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WorkspaceObjectAdd(ctx, req.(*pb.RpcWorkspaceObjectAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WorkspaceObjectAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWorkspaceObjectAddResponse)
}
func (h *ClientCommandsHandlerProxy) WorkspaceObjectListAdd(ctx context.Context, req *pb.RpcWorkspaceObjectListAddRequest) *pb.RpcWorkspaceObjectListAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WorkspaceObjectListAdd(ctx, req.(*pb.RpcWorkspaceObjectListAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WorkspaceObjectListAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWorkspaceObjectListAddResponse)
}
func (h *ClientCommandsHandlerProxy) WorkspaceObjectListRemove(ctx context.Context, req *pb.RpcWorkspaceObjectListRemoveRequest) *pb.RpcWorkspaceObjectListRemoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WorkspaceObjectListRemove(ctx, req.(*pb.RpcWorkspaceObjectListRemoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WorkspaceObjectListRemove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWorkspaceObjectListRemoveResponse)
}
func (h *ClientCommandsHandlerProxy) WorkspaceSelect(ctx context.Context, req *pb.RpcWorkspaceSelectRequest) *pb.RpcWorkspaceSelectResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WorkspaceSelect(ctx, req.(*pb.RpcWorkspaceSelectRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WorkspaceSelect", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWorkspaceSelectResponse)
}
func (h *ClientCommandsHandlerProxy) WorkspaceGetCurrent(ctx context.Context, req *pb.RpcWorkspaceGetCurrentRequest) *pb.RpcWorkspaceGetCurrentResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WorkspaceGetCurrent(ctx, req.(*pb.RpcWorkspaceGetCurrentRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WorkspaceGetCurrent", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWorkspaceGetCurrentResponse)
}
func (h *ClientCommandsHandlerProxy) WorkspaceGetAll(ctx context.Context, req *pb.RpcWorkspaceGetAllRequest) *pb.RpcWorkspaceGetAllResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WorkspaceGetAll(ctx, req.(*pb.RpcWorkspaceGetAllRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WorkspaceGetAll", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWorkspaceGetAllResponse)
}
func (h *ClientCommandsHandlerProxy) WorkspaceSetInfo(ctx context.Context, req *pb.RpcWorkspaceSetInfoRequest) *pb.RpcWorkspaceSetInfoResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WorkspaceSetInfo(ctx, req.(*pb.RpcWorkspaceSetInfoRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WorkspaceSetInfo", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWorkspaceSetInfoResponse)
}
func (h *ClientCommandsHandlerProxy) WorkspaceExport(ctx context.Context, req *pb.RpcWorkspaceExportRequest) *pb.RpcWorkspaceExportResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.WorkspaceExport(ctx, req.(*pb.RpcWorkspaceExportRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "WorkspaceExport", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcWorkspaceExportResponse)
}
func (h *ClientCommandsHandlerProxy) AccountRecover(ctx context.Context, req *pb.RpcAccountRecoverRequest) *pb.RpcAccountRecoverResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountRecover(ctx, req.(*pb.RpcAccountRecoverRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountRecover", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountRecoverResponse)
}
func (h *ClientCommandsHandlerProxy) AccountMigrate(ctx context.Context, req *pb.RpcAccountMigrateRequest) *pb.RpcAccountMigrateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountMigrate(ctx, req.(*pb.RpcAccountMigrateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountMigrate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountMigrateResponse)
}
func (h *ClientCommandsHandlerProxy) AccountMigrateCancel(ctx context.Context, req *pb.RpcAccountMigrateCancelRequest) *pb.RpcAccountMigrateCancelResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountMigrateCancel(ctx, req.(*pb.RpcAccountMigrateCancelRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountMigrateCancel", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountMigrateCancelResponse)
}
func (h *ClientCommandsHandlerProxy) AccountCreate(ctx context.Context, req *pb.RpcAccountCreateRequest) *pb.RpcAccountCreateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountCreate(ctx, req.(*pb.RpcAccountCreateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountCreate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountCreateResponse)
}
func (h *ClientCommandsHandlerProxy) AccountDelete(ctx context.Context, req *pb.RpcAccountDeleteRequest) *pb.RpcAccountDeleteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountDelete(ctx, req.(*pb.RpcAccountDeleteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountDelete", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountDeleteResponse)
}
func (h *ClientCommandsHandlerProxy) AccountRevertDeletion(ctx context.Context, req *pb.RpcAccountRevertDeletionRequest) *pb.RpcAccountRevertDeletionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountRevertDeletion(ctx, req.(*pb.RpcAccountRevertDeletionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountRevertDeletion", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountRevertDeletionResponse)
}
func (h *ClientCommandsHandlerProxy) AccountSelect(ctx context.Context, req *pb.RpcAccountSelectRequest) *pb.RpcAccountSelectResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountSelect(ctx, req.(*pb.RpcAccountSelectRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountSelect", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountSelectResponse)
}
func (h *ClientCommandsHandlerProxy) AccountEnableLocalNetworkSync(ctx context.Context, req *pb.RpcAccountEnableLocalNetworkSyncRequest) *pb.RpcAccountEnableLocalNetworkSyncResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountEnableLocalNetworkSync(ctx, req.(*pb.RpcAccountEnableLocalNetworkSyncRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountEnableLocalNetworkSync", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountEnableLocalNetworkSyncResponse)
}
func (h *ClientCommandsHandlerProxy) AccountChangeJsonApiAddr(ctx context.Context, req *pb.RpcAccountChangeJsonApiAddrRequest) *pb.RpcAccountChangeJsonApiAddrResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountChangeJsonApiAddr(ctx, req.(*pb.RpcAccountChangeJsonApiAddrRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountChangeJsonApiAddr", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountChangeJsonApiAddrResponse)
}
func (h *ClientCommandsHandlerProxy) AccountStop(ctx context.Context, req *pb.RpcAccountStopRequest) *pb.RpcAccountStopResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountStop(ctx, req.(*pb.RpcAccountStopRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountStop", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountStopResponse)
}
func (h *ClientCommandsHandlerProxy) AccountMove(ctx context.Context, req *pb.RpcAccountMoveRequest) *pb.RpcAccountMoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountMove(ctx, req.(*pb.RpcAccountMoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountMove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountMoveResponse)
}
func (h *ClientCommandsHandlerProxy) AccountConfigUpdate(ctx context.Context, req *pb.RpcAccountConfigUpdateRequest) *pb.RpcAccountConfigUpdateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountConfigUpdate(ctx, req.(*pb.RpcAccountConfigUpdateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountConfigUpdate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountConfigUpdateResponse)
}
func (h *ClientCommandsHandlerProxy) AccountRecoverFromLegacyExport(ctx context.Context, req *pb.RpcAccountRecoverFromLegacyExportRequest) *pb.RpcAccountRecoverFromLegacyExportResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountRecoverFromLegacyExport(ctx, req.(*pb.RpcAccountRecoverFromLegacyExportRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountRecoverFromLegacyExport", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountRecoverFromLegacyExportResponse)
}
func (h *ClientCommandsHandlerProxy) AccountChangeNetworkConfigAndRestart(ctx context.Context, req *pb.RpcAccountChangeNetworkConfigAndRestartRequest) *pb.RpcAccountChangeNetworkConfigAndRestartResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AccountChangeNetworkConfigAndRestart(ctx, req.(*pb.RpcAccountChangeNetworkConfigAndRestartRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AccountChangeNetworkConfigAndRestart", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAccountChangeNetworkConfigAndRestartResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceDelete(ctx context.Context, req *pb.RpcSpaceDeleteRequest) *pb.RpcSpaceDeleteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceDelete(ctx, req.(*pb.RpcSpaceDeleteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceDelete", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceDeleteResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceInviteGenerate(ctx context.Context, req *pb.RpcSpaceInviteGenerateRequest) *pb.RpcSpaceInviteGenerateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceInviteGenerate(ctx, req.(*pb.RpcSpaceInviteGenerateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceInviteGenerate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceInviteGenerateResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceInviteChange(ctx context.Context, req *pb.RpcSpaceInviteChangeRequest) *pb.RpcSpaceInviteChangeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceInviteChange(ctx, req.(*pb.RpcSpaceInviteChangeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceInviteChange", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceInviteChangeResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceInviteGetCurrent(ctx context.Context, req *pb.RpcSpaceInviteGetCurrentRequest) *pb.RpcSpaceInviteGetCurrentResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceInviteGetCurrent(ctx, req.(*pb.RpcSpaceInviteGetCurrentRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceInviteGetCurrent", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceInviteGetCurrentResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceInviteGetGuest(ctx context.Context, req *pb.RpcSpaceInviteGetGuestRequest) *pb.RpcSpaceInviteGetGuestResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceInviteGetGuest(ctx, req.(*pb.RpcSpaceInviteGetGuestRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceInviteGetGuest", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceInviteGetGuestResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceInviteRevoke(ctx context.Context, req *pb.RpcSpaceInviteRevokeRequest) *pb.RpcSpaceInviteRevokeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceInviteRevoke(ctx, req.(*pb.RpcSpaceInviteRevokeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceInviteRevoke", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceInviteRevokeResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceInviteView(ctx context.Context, req *pb.RpcSpaceInviteViewRequest) *pb.RpcSpaceInviteViewResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceInviteView(ctx, req.(*pb.RpcSpaceInviteViewRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceInviteView", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceInviteViewResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceJoin(ctx context.Context, req *pb.RpcSpaceJoinRequest) *pb.RpcSpaceJoinResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceJoin(ctx, req.(*pb.RpcSpaceJoinRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceJoin", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceJoinResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceJoinCancel(ctx context.Context, req *pb.RpcSpaceJoinCancelRequest) *pb.RpcSpaceJoinCancelResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceJoinCancel(ctx, req.(*pb.RpcSpaceJoinCancelRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceJoinCancel", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceJoinCancelResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceStopSharing(ctx context.Context, req *pb.RpcSpaceStopSharingRequest) *pb.RpcSpaceStopSharingResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceStopSharing(ctx, req.(*pb.RpcSpaceStopSharingRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceStopSharing", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceStopSharingResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceRequestApprove(ctx context.Context, req *pb.RpcSpaceRequestApproveRequest) *pb.RpcSpaceRequestApproveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceRequestApprove(ctx, req.(*pb.RpcSpaceRequestApproveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceRequestApprove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceRequestApproveResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceRequestDecline(ctx context.Context, req *pb.RpcSpaceRequestDeclineRequest) *pb.RpcSpaceRequestDeclineResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceRequestDecline(ctx, req.(*pb.RpcSpaceRequestDeclineRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceRequestDecline", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceRequestDeclineResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceLeaveApprove(ctx context.Context, req *pb.RpcSpaceLeaveApproveRequest) *pb.RpcSpaceLeaveApproveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceLeaveApprove(ctx, req.(*pb.RpcSpaceLeaveApproveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceLeaveApprove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceLeaveApproveResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceMakeShareable(ctx context.Context, req *pb.RpcSpaceMakeShareableRequest) *pb.RpcSpaceMakeShareableResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceMakeShareable(ctx, req.(*pb.RpcSpaceMakeShareableRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceMakeShareable", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceMakeShareableResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceParticipantRemove(ctx context.Context, req *pb.RpcSpaceParticipantRemoveRequest) *pb.RpcSpaceParticipantRemoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceParticipantRemove(ctx, req.(*pb.RpcSpaceParticipantRemoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceParticipantRemove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceParticipantRemoveResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceParticipantPermissionsChange(ctx context.Context, req *pb.RpcSpaceParticipantPermissionsChangeRequest) *pb.RpcSpaceParticipantPermissionsChangeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceParticipantPermissionsChange(ctx, req.(*pb.RpcSpaceParticipantPermissionsChangeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceParticipantPermissionsChange", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceParticipantPermissionsChangeResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceSetOrder(ctx context.Context, req *pb.RpcSpaceSetOrderRequest) *pb.RpcSpaceSetOrderResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceSetOrder(ctx, req.(*pb.RpcSpaceSetOrderRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceSetOrder", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceSetOrderResponse)
}
func (h *ClientCommandsHandlerProxy) SpaceUnsetOrder(ctx context.Context, req *pb.RpcSpaceUnsetOrderRequest) *pb.RpcSpaceUnsetOrderResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.SpaceUnsetOrder(ctx, req.(*pb.RpcSpaceUnsetOrderRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "SpaceUnsetOrder", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcSpaceUnsetOrderResponse)
}
func (h *ClientCommandsHandlerProxy) PublishingCreate(ctx context.Context, req *pb.RpcPublishingCreateRequest) *pb.RpcPublishingCreateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.PublishingCreate(ctx, req.(*pb.RpcPublishingCreateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "PublishingCreate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcPublishingCreateResponse)
}
func (h *ClientCommandsHandlerProxy) PublishingRemove(ctx context.Context, req *pb.RpcPublishingRemoveRequest) *pb.RpcPublishingRemoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.PublishingRemove(ctx, req.(*pb.RpcPublishingRemoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "PublishingRemove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcPublishingRemoveResponse)
}
func (h *ClientCommandsHandlerProxy) PublishingList(ctx context.Context, req *pb.RpcPublishingListRequest) *pb.RpcPublishingListResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.PublishingList(ctx, req.(*pb.RpcPublishingListRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "PublishingList", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcPublishingListResponse)
}
func (h *ClientCommandsHandlerProxy) PublishingResolveUri(ctx context.Context, req *pb.RpcPublishingResolveUriRequest) *pb.RpcPublishingResolveUriResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.PublishingResolveUri(ctx, req.(*pb.RpcPublishingResolveUriRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "PublishingResolveUri", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcPublishingResolveUriResponse)
}
func (h *ClientCommandsHandlerProxy) PublishingGetStatus(ctx context.Context, req *pb.RpcPublishingGetStatusRequest) *pb.RpcPublishingGetStatusResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.PublishingGetStatus(ctx, req.(*pb.RpcPublishingGetStatusRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "PublishingGetStatus", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcPublishingGetStatusResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectOpen(ctx context.Context, req *pb.RpcObjectOpenRequest) *pb.RpcObjectOpenResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectOpen(ctx, req.(*pb.RpcObjectOpenRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectOpen", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectOpenResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectRefresh(ctx context.Context, req *pb.RpcObjectRefreshRequest) *pb.RpcObjectRefreshResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectRefresh(ctx, req.(*pb.RpcObjectRefreshRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectRefresh", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectRefreshResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectClose(ctx context.Context, req *pb.RpcObjectCloseRequest) *pb.RpcObjectCloseResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectClose(ctx, req.(*pb.RpcObjectCloseRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectClose", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCloseResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectShow(ctx context.Context, req *pb.RpcObjectShowRequest) *pb.RpcObjectShowResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectShow(ctx, req.(*pb.RpcObjectShowRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectShow", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectShowResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCreate(ctx context.Context, req *pb.RpcObjectCreateRequest) *pb.RpcObjectCreateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCreate(ctx, req.(*pb.RpcObjectCreateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCreate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCreateResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCreateBookmark(ctx context.Context, req *pb.RpcObjectCreateBookmarkRequest) *pb.RpcObjectCreateBookmarkResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCreateBookmark(ctx, req.(*pb.RpcObjectCreateBookmarkRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCreateBookmark", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCreateBookmarkResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCreateFromUrl(ctx context.Context, req *pb.RpcObjectCreateFromUrlRequest) *pb.RpcObjectCreateFromUrlResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCreateFromUrl(ctx, req.(*pb.RpcObjectCreateFromUrlRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCreateFromUrl", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCreateFromUrlResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCreateSet(ctx context.Context, req *pb.RpcObjectCreateSetRequest) *pb.RpcObjectCreateSetResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCreateSet(ctx, req.(*pb.RpcObjectCreateSetRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCreateSet", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCreateSetResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectGraph(ctx context.Context, req *pb.RpcObjectGraphRequest) *pb.RpcObjectGraphResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectGraph(ctx, req.(*pb.RpcObjectGraphRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectGraph", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectGraphResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSearch(ctx context.Context, req *pb.RpcObjectSearchRequest) *pb.RpcObjectSearchResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSearch(ctx, req.(*pb.RpcObjectSearchRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSearch", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSearchResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSearchWithMeta(ctx context.Context, req *pb.RpcObjectSearchWithMetaRequest) *pb.RpcObjectSearchWithMetaResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSearchWithMeta(ctx, req.(*pb.RpcObjectSearchWithMetaRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSearchWithMeta", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSearchWithMetaResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSearchSubscribe(ctx context.Context, req *pb.RpcObjectSearchSubscribeRequest) *pb.RpcObjectSearchSubscribeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSearchSubscribe(ctx, req.(*pb.RpcObjectSearchSubscribeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSearchSubscribe", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSearchSubscribeResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCrossSpaceSearchSubscribe(ctx context.Context, req *pb.RpcObjectCrossSpaceSearchSubscribeRequest) *pb.RpcObjectCrossSpaceSearchSubscribeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCrossSpaceSearchSubscribe(ctx, req.(*pb.RpcObjectCrossSpaceSearchSubscribeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCrossSpaceSearchSubscribe", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCrossSpaceSearchSubscribeResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCrossSpaceSearchUnsubscribe(ctx context.Context, req *pb.RpcObjectCrossSpaceSearchUnsubscribeRequest) *pb.RpcObjectCrossSpaceSearchUnsubscribeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCrossSpaceSearchUnsubscribe(ctx, req.(*pb.RpcObjectCrossSpaceSearchUnsubscribeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCrossSpaceSearchUnsubscribe", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCrossSpaceSearchUnsubscribeResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSubscribeIds(ctx context.Context, req *pb.RpcObjectSubscribeIdsRequest) *pb.RpcObjectSubscribeIdsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSubscribeIds(ctx, req.(*pb.RpcObjectSubscribeIdsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSubscribeIds", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSubscribeIdsResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectGroupsSubscribe(ctx context.Context, req *pb.RpcObjectGroupsSubscribeRequest) *pb.RpcObjectGroupsSubscribeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectGroupsSubscribe(ctx, req.(*pb.RpcObjectGroupsSubscribeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectGroupsSubscribe", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectGroupsSubscribeResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSearchUnsubscribe(ctx context.Context, req *pb.RpcObjectSearchUnsubscribeRequest) *pb.RpcObjectSearchUnsubscribeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSearchUnsubscribe(ctx, req.(*pb.RpcObjectSearchUnsubscribeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSearchUnsubscribe", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSearchUnsubscribeResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSetDetails(ctx context.Context, req *pb.RpcObjectSetDetailsRequest) *pb.RpcObjectSetDetailsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSetDetails(ctx, req.(*pb.RpcObjectSetDetailsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSetDetails", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSetDetailsResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectDuplicate(ctx context.Context, req *pb.RpcObjectDuplicateRequest) *pb.RpcObjectDuplicateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectDuplicate(ctx, req.(*pb.RpcObjectDuplicateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectDuplicate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectDuplicateResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSetObjectType(ctx context.Context, req *pb.RpcObjectSetObjectTypeRequest) *pb.RpcObjectSetObjectTypeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSetObjectType(ctx, req.(*pb.RpcObjectSetObjectTypeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSetObjectType", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSetObjectTypeResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSetLayout(ctx context.Context, req *pb.RpcObjectSetLayoutRequest) *pb.RpcObjectSetLayoutResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSetLayout(ctx, req.(*pb.RpcObjectSetLayoutRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSetLayout", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSetLayoutResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSetInternalFlags(ctx context.Context, req *pb.RpcObjectSetInternalFlagsRequest) *pb.RpcObjectSetInternalFlagsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSetInternalFlags(ctx, req.(*pb.RpcObjectSetInternalFlagsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSetInternalFlags", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSetInternalFlagsResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSetIsFavorite(ctx context.Context, req *pb.RpcObjectSetIsFavoriteRequest) *pb.RpcObjectSetIsFavoriteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSetIsFavorite(ctx, req.(*pb.RpcObjectSetIsFavoriteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSetIsFavorite", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSetIsFavoriteResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSetIsArchived(ctx context.Context, req *pb.RpcObjectSetIsArchivedRequest) *pb.RpcObjectSetIsArchivedResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSetIsArchived(ctx, req.(*pb.RpcObjectSetIsArchivedRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSetIsArchived", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSetIsArchivedResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectSetSource(ctx context.Context, req *pb.RpcObjectSetSourceRequest) *pb.RpcObjectSetSourceResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectSetSource(ctx, req.(*pb.RpcObjectSetSourceRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectSetSource", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectSetSourceResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectWorkspaceSetDashboard(ctx context.Context, req *pb.RpcObjectWorkspaceSetDashboardRequest) *pb.RpcObjectWorkspaceSetDashboardResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectWorkspaceSetDashboard(ctx, req.(*pb.RpcObjectWorkspaceSetDashboardRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectWorkspaceSetDashboard", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectWorkspaceSetDashboardResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectListDuplicate(ctx context.Context, req *pb.RpcObjectListDuplicateRequest) *pb.RpcObjectListDuplicateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectListDuplicate(ctx, req.(*pb.RpcObjectListDuplicateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectListDuplicate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectListDuplicateResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectListDelete(ctx context.Context, req *pb.RpcObjectListDeleteRequest) *pb.RpcObjectListDeleteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectListDelete(ctx, req.(*pb.RpcObjectListDeleteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectListDelete", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectListDeleteResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectListSetIsArchived(ctx context.Context, req *pb.RpcObjectListSetIsArchivedRequest) *pb.RpcObjectListSetIsArchivedResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectListSetIsArchived(ctx, req.(*pb.RpcObjectListSetIsArchivedRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectListSetIsArchived", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectListSetIsArchivedResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectListSetIsFavorite(ctx context.Context, req *pb.RpcObjectListSetIsFavoriteRequest) *pb.RpcObjectListSetIsFavoriteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectListSetIsFavorite(ctx, req.(*pb.RpcObjectListSetIsFavoriteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectListSetIsFavorite", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectListSetIsFavoriteResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectListSetObjectType(ctx context.Context, req *pb.RpcObjectListSetObjectTypeRequest) *pb.RpcObjectListSetObjectTypeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectListSetObjectType(ctx, req.(*pb.RpcObjectListSetObjectTypeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectListSetObjectType", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectListSetObjectTypeResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectListSetDetails(ctx context.Context, req *pb.RpcObjectListSetDetailsRequest) *pb.RpcObjectListSetDetailsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectListSetDetails(ctx, req.(*pb.RpcObjectListSetDetailsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectListSetDetails", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectListSetDetailsResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectListModifyDetailValues(ctx context.Context, req *pb.RpcObjectListModifyDetailValuesRequest) *pb.RpcObjectListModifyDetailValuesResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectListModifyDetailValues(ctx, req.(*pb.RpcObjectListModifyDetailValuesRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectListModifyDetailValues", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectListModifyDetailValuesResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectApplyTemplate(ctx context.Context, req *pb.RpcObjectApplyTemplateRequest) *pb.RpcObjectApplyTemplateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectApplyTemplate(ctx, req.(*pb.RpcObjectApplyTemplateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectApplyTemplate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectApplyTemplateResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectToSet(ctx context.Context, req *pb.RpcObjectToSetRequest) *pb.RpcObjectToSetResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectToSet(ctx, req.(*pb.RpcObjectToSetRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectToSet", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectToSetResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectToCollection(ctx context.Context, req *pb.RpcObjectToCollectionRequest) *pb.RpcObjectToCollectionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectToCollection(ctx, req.(*pb.RpcObjectToCollectionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectToCollection", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectToCollectionResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectShareByLink(ctx context.Context, req *pb.RpcObjectShareByLinkRequest) *pb.RpcObjectShareByLinkResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectShareByLink(ctx, req.(*pb.RpcObjectShareByLinkRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectShareByLink", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectShareByLinkResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectUndo(ctx context.Context, req *pb.RpcObjectUndoRequest) *pb.RpcObjectUndoResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectUndo(ctx, req.(*pb.RpcObjectUndoRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectUndo", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectUndoResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectRedo(ctx context.Context, req *pb.RpcObjectRedoRequest) *pb.RpcObjectRedoResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectRedo(ctx, req.(*pb.RpcObjectRedoRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectRedo", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectRedoResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectListExport(ctx context.Context, req *pb.RpcObjectListExportRequest) *pb.RpcObjectListExportResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectListExport(ctx, req.(*pb.RpcObjectListExportRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectListExport", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectListExportResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectExport(ctx context.Context, req *pb.RpcObjectExportRequest) *pb.RpcObjectExportResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectExport(ctx, req.(*pb.RpcObjectExportRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectExport", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectExportResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectBookmarkFetch(ctx context.Context, req *pb.RpcObjectBookmarkFetchRequest) *pb.RpcObjectBookmarkFetchResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectBookmarkFetch(ctx, req.(*pb.RpcObjectBookmarkFetchRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectBookmarkFetch", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectBookmarkFetchResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectImport(ctx context.Context, req *pb.RpcObjectImportRequest) *pb.RpcObjectImportResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectImport(ctx, req.(*pb.RpcObjectImportRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectImport", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectImportResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectImportList(ctx context.Context, req *pb.RpcObjectImportListRequest) *pb.RpcObjectImportListResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectImportList(ctx, req.(*pb.RpcObjectImportListRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectImportList", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectImportListResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectImportNotionValidateToken(ctx context.Context, req *pb.RpcObjectImportNotionValidateTokenRequest) *pb.RpcObjectImportNotionValidateTokenResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectImportNotionValidateToken(ctx, req.(*pb.RpcObjectImportNotionValidateTokenRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectImportNotionValidateToken", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectImportNotionValidateTokenResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectImportUseCase(ctx context.Context, req *pb.RpcObjectImportUseCaseRequest) *pb.RpcObjectImportUseCaseResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectImportUseCase(ctx, req.(*pb.RpcObjectImportUseCaseRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectImportUseCase", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectImportUseCaseResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectImportExperience(ctx context.Context, req *pb.RpcObjectImportExperienceRequest) *pb.RpcObjectImportExperienceResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectImportExperience(ctx, req.(*pb.RpcObjectImportExperienceRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectImportExperience", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectImportExperienceResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectDateByTimestamp(ctx context.Context, req *pb.RpcObjectDateByTimestampRequest) *pb.RpcObjectDateByTimestampResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectDateByTimestamp(ctx, req.(*pb.RpcObjectDateByTimestampRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectDateByTimestamp", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectDateByTimestampResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCollectionAdd(ctx context.Context, req *pb.RpcObjectCollectionAddRequest) *pb.RpcObjectCollectionAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCollectionAdd(ctx, req.(*pb.RpcObjectCollectionAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCollectionAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCollectionAddResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCollectionRemove(ctx context.Context, req *pb.RpcObjectCollectionRemoveRequest) *pb.RpcObjectCollectionRemoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCollectionRemove(ctx, req.(*pb.RpcObjectCollectionRemoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCollectionRemove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCollectionRemoveResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCollectionSort(ctx context.Context, req *pb.RpcObjectCollectionSortRequest) *pb.RpcObjectCollectionSortResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCollectionSort(ctx, req.(*pb.RpcObjectCollectionSortRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCollectionSort", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCollectionSortResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCreateRelation(ctx context.Context, req *pb.RpcObjectCreateRelationRequest) *pb.RpcObjectCreateRelationResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCreateRelation(ctx, req.(*pb.RpcObjectCreateRelationRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCreateRelation", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCreateRelationResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCreateRelationOption(ctx context.Context, req *pb.RpcObjectCreateRelationOptionRequest) *pb.RpcObjectCreateRelationOptionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCreateRelationOption(ctx, req.(*pb.RpcObjectCreateRelationOptionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCreateRelationOption", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCreateRelationOptionResponse)
}
func (h *ClientCommandsHandlerProxy) RelationListRemoveOption(ctx context.Context, req *pb.RpcRelationListRemoveOptionRequest) *pb.RpcRelationListRemoveOptionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.RelationListRemoveOption(ctx, req.(*pb.RpcRelationListRemoveOptionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "RelationListRemoveOption", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcRelationListRemoveOptionResponse)
}
func (h *ClientCommandsHandlerProxy) RelationOptions(ctx context.Context, req *pb.RpcRelationOptionsRequest) *pb.RpcRelationOptionsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.RelationOptions(ctx, req.(*pb.RpcRelationOptionsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "RelationOptions", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcRelationOptionsResponse)
}
func (h *ClientCommandsHandlerProxy) RelationOptionSetOrder(ctx context.Context, req *pb.RpcRelationOptionSetOrderRequest) *pb.RpcRelationOptionSetOrderResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.RelationOptionSetOrder(ctx, req.(*pb.RpcRelationOptionSetOrderRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "RelationOptionSetOrder", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcRelationOptionSetOrderResponse)
}
func (h *ClientCommandsHandlerProxy) RelationListWithValue(ctx context.Context, req *pb.RpcRelationListWithValueRequest) *pb.RpcRelationListWithValueResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.RelationListWithValue(ctx, req.(*pb.RpcRelationListWithValueRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "RelationListWithValue", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcRelationListWithValueResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectRelationAdd(ctx context.Context, req *pb.RpcObjectRelationAddRequest) *pb.RpcObjectRelationAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectRelationAdd(ctx, req.(*pb.RpcObjectRelationAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectRelationAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectRelationAddResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectRelationDelete(ctx context.Context, req *pb.RpcObjectRelationDeleteRequest) *pb.RpcObjectRelationDeleteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectRelationDelete(ctx, req.(*pb.RpcObjectRelationDeleteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectRelationDelete", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectRelationDeleteResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectRelationAddFeatured(ctx context.Context, req *pb.RpcObjectRelationAddFeaturedRequest) *pb.RpcObjectRelationAddFeaturedResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectRelationAddFeatured(ctx, req.(*pb.RpcObjectRelationAddFeaturedRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectRelationAddFeatured", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectRelationAddFeaturedResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectRelationRemoveFeatured(ctx context.Context, req *pb.RpcObjectRelationRemoveFeaturedRequest) *pb.RpcObjectRelationRemoveFeaturedResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectRelationRemoveFeatured(ctx, req.(*pb.RpcObjectRelationRemoveFeaturedRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectRelationRemoveFeatured", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectRelationRemoveFeaturedResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectRelationListAvailable(ctx context.Context, req *pb.RpcObjectRelationListAvailableRequest) *pb.RpcObjectRelationListAvailableResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectRelationListAvailable(ctx, req.(*pb.RpcObjectRelationListAvailableRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectRelationListAvailable", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectRelationListAvailableResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectCreateObjectType(ctx context.Context, req *pb.RpcObjectCreateObjectTypeRequest) *pb.RpcObjectCreateObjectTypeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectCreateObjectType(ctx, req.(*pb.RpcObjectCreateObjectTypeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectCreateObjectType", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectCreateObjectTypeResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectTypeRelationAdd(ctx context.Context, req *pb.RpcObjectTypeRelationAddRequest) *pb.RpcObjectTypeRelationAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectTypeRelationAdd(ctx, req.(*pb.RpcObjectTypeRelationAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectTypeRelationAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectTypeRelationAddResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectTypeRelationRemove(ctx context.Context, req *pb.RpcObjectTypeRelationRemoveRequest) *pb.RpcObjectTypeRelationRemoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectTypeRelationRemove(ctx, req.(*pb.RpcObjectTypeRelationRemoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectTypeRelationRemove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectTypeRelationRemoveResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectTypeRecommendedRelationsSet(ctx context.Context, req *pb.RpcObjectTypeRecommendedRelationsSetRequest) *pb.RpcObjectTypeRecommendedRelationsSetResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectTypeRecommendedRelationsSet(ctx, req.(*pb.RpcObjectTypeRecommendedRelationsSetRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectTypeRecommendedRelationsSet", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectTypeRecommendedRelationsSetResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectTypeRecommendedFeaturedRelationsSet(ctx context.Context, req *pb.RpcObjectTypeRecommendedFeaturedRelationsSetRequest) *pb.RpcObjectTypeRecommendedFeaturedRelationsSetResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectTypeRecommendedFeaturedRelationsSet(ctx, req.(*pb.RpcObjectTypeRecommendedFeaturedRelationsSetRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectTypeRecommendedFeaturedRelationsSet", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectTypeRecommendedFeaturedRelationsSetResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectTypeListConflictingRelations(ctx context.Context, req *pb.RpcObjectTypeListConflictingRelationsRequest) *pb.RpcObjectTypeListConflictingRelationsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectTypeListConflictingRelations(ctx, req.(*pb.RpcObjectTypeListConflictingRelationsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectTypeListConflictingRelations", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectTypeListConflictingRelationsResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectTypeResolveLayoutConflicts(ctx context.Context, req *pb.RpcObjectTypeResolveLayoutConflictsRequest) *pb.RpcObjectTypeResolveLayoutConflictsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectTypeResolveLayoutConflicts(ctx, req.(*pb.RpcObjectTypeResolveLayoutConflictsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectTypeResolveLayoutConflicts", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectTypeResolveLayoutConflictsResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectTypeSetOrder(ctx context.Context, req *pb.RpcObjectTypeSetOrderRequest) *pb.RpcObjectTypeSetOrderResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectTypeSetOrder(ctx, req.(*pb.RpcObjectTypeSetOrderRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectTypeSetOrder", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectTypeSetOrderResponse)
}
func (h *ClientCommandsHandlerProxy) HistoryShowVersion(ctx context.Context, req *pb.RpcHistoryShowVersionRequest) *pb.RpcHistoryShowVersionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.HistoryShowVersion(ctx, req.(*pb.RpcHistoryShowVersionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "HistoryShowVersion", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcHistoryShowVersionResponse)
}
func (h *ClientCommandsHandlerProxy) HistoryGetVersions(ctx context.Context, req *pb.RpcHistoryGetVersionsRequest) *pb.RpcHistoryGetVersionsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.HistoryGetVersions(ctx, req.(*pb.RpcHistoryGetVersionsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "HistoryGetVersions", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcHistoryGetVersionsResponse)
}
func (h *ClientCommandsHandlerProxy) HistorySetVersion(ctx context.Context, req *pb.RpcHistorySetVersionRequest) *pb.RpcHistorySetVersionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.HistorySetVersion(ctx, req.(*pb.RpcHistorySetVersionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "HistorySetVersion", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcHistorySetVersionResponse)
}
func (h *ClientCommandsHandlerProxy) HistoryDiffVersions(ctx context.Context, req *pb.RpcHistoryDiffVersionsRequest) *pb.RpcHistoryDiffVersionsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.HistoryDiffVersions(ctx, req.(*pb.RpcHistoryDiffVersionsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "HistoryDiffVersions", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcHistoryDiffVersionsResponse)
}
func (h *ClientCommandsHandlerProxy) FileSpaceOffload(ctx context.Context, req *pb.RpcFileSpaceOffloadRequest) *pb.RpcFileSpaceOffloadResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.FileSpaceOffload(ctx, req.(*pb.RpcFileSpaceOffloadRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "FileSpaceOffload", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcFileSpaceOffloadResponse)
}
func (h *ClientCommandsHandlerProxy) FileReconcile(ctx context.Context, req *pb.RpcFileReconcileRequest) *pb.RpcFileReconcileResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.FileReconcile(ctx, req.(*pb.RpcFileReconcileRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "FileReconcile", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcFileReconcileResponse)
}
func (h *ClientCommandsHandlerProxy) FileListOffload(ctx context.Context, req *pb.RpcFileListOffloadRequest) *pb.RpcFileListOffloadResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.FileListOffload(ctx, req.(*pb.RpcFileListOffloadRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "FileListOffload", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcFileListOffloadResponse)
}
func (h *ClientCommandsHandlerProxy) FileUpload(ctx context.Context, req *pb.RpcFileUploadRequest) *pb.RpcFileUploadResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.FileUpload(ctx, req.(*pb.RpcFileUploadRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "FileUpload", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcFileUploadResponse)
}
func (h *ClientCommandsHandlerProxy) FileDownload(ctx context.Context, req *pb.RpcFileDownloadRequest) *pb.RpcFileDownloadResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.FileDownload(ctx, req.(*pb.RpcFileDownloadRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "FileDownload", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcFileDownloadResponse)
}
func (h *ClientCommandsHandlerProxy) FileDiscardPreload(ctx context.Context, req *pb.RpcFileDiscardPreloadRequest) *pb.RpcFileDiscardPreloadResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.FileDiscardPreload(ctx, req.(*pb.RpcFileDiscardPreloadRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "FileDiscardPreload", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcFileDiscardPreloadResponse)
}
func (h *ClientCommandsHandlerProxy) FileDrop(ctx context.Context, req *pb.RpcFileDropRequest) *pb.RpcFileDropResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.FileDrop(ctx, req.(*pb.RpcFileDropRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "FileDrop", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcFileDropResponse)
}
func (h *ClientCommandsHandlerProxy) FileSpaceUsage(ctx context.Context, req *pb.RpcFileSpaceUsageRequest) *pb.RpcFileSpaceUsageResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.FileSpaceUsage(ctx, req.(*pb.RpcFileSpaceUsageRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "FileSpaceUsage", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcFileSpaceUsageResponse)
}
func (h *ClientCommandsHandlerProxy) FileNodeUsage(ctx context.Context, req *pb.RpcFileNodeUsageRequest) *pb.RpcFileNodeUsageResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.FileNodeUsage(ctx, req.(*pb.RpcFileNodeUsageRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "FileNodeUsage", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcFileNodeUsageResponse)
}
func (h *ClientCommandsHandlerProxy) NavigationListObjects(ctx context.Context, req *pb.RpcNavigationListObjectsRequest) *pb.RpcNavigationListObjectsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.NavigationListObjects(ctx, req.(*pb.RpcNavigationListObjectsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "NavigationListObjects", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcNavigationListObjectsResponse)
}
func (h *ClientCommandsHandlerProxy) NavigationGetObjectInfoWithLinks(ctx context.Context, req *pb.RpcNavigationGetObjectInfoWithLinksRequest) *pb.RpcNavigationGetObjectInfoWithLinksResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.NavigationGetObjectInfoWithLinks(ctx, req.(*pb.RpcNavigationGetObjectInfoWithLinksRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "NavigationGetObjectInfoWithLinks", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcNavigationGetObjectInfoWithLinksResponse)
}
func (h *ClientCommandsHandlerProxy) TemplateCreateFromObject(ctx context.Context, req *pb.RpcTemplateCreateFromObjectRequest) *pb.RpcTemplateCreateFromObjectResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.TemplateCreateFromObject(ctx, req.(*pb.RpcTemplateCreateFromObjectRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "TemplateCreateFromObject", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcTemplateCreateFromObjectResponse)
}
func (h *ClientCommandsHandlerProxy) TemplateClone(ctx context.Context, req *pb.RpcTemplateCloneRequest) *pb.RpcTemplateCloneResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.TemplateClone(ctx, req.(*pb.RpcTemplateCloneRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "TemplateClone", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcTemplateCloneResponse)
}
func (h *ClientCommandsHandlerProxy) TemplateExportAll(ctx context.Context, req *pb.RpcTemplateExportAllRequest) *pb.RpcTemplateExportAllResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.TemplateExportAll(ctx, req.(*pb.RpcTemplateExportAllRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "TemplateExportAll", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcTemplateExportAllResponse)
}
func (h *ClientCommandsHandlerProxy) LinkPreview(ctx context.Context, req *pb.RpcLinkPreviewRequest) *pb.RpcLinkPreviewResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.LinkPreview(ctx, req.(*pb.RpcLinkPreviewRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "LinkPreview", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcLinkPreviewResponse)
}
func (h *ClientCommandsHandlerProxy) UnsplashSearch(ctx context.Context, req *pb.RpcUnsplashSearchRequest) *pb.RpcUnsplashSearchResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.UnsplashSearch(ctx, req.(*pb.RpcUnsplashSearchRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "UnsplashSearch", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcUnsplashSearchResponse)
}
func (h *ClientCommandsHandlerProxy) UnsplashDownload(ctx context.Context, req *pb.RpcUnsplashDownloadRequest) *pb.RpcUnsplashDownloadResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.UnsplashDownload(ctx, req.(*pb.RpcUnsplashDownloadRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "UnsplashDownload", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcUnsplashDownloadResponse)
}
func (h *ClientCommandsHandlerProxy) GalleryDownloadManifest(ctx context.Context, req *pb.RpcGalleryDownloadManifestRequest) *pb.RpcGalleryDownloadManifestResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.GalleryDownloadManifest(ctx, req.(*pb.RpcGalleryDownloadManifestRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "GalleryDownloadManifest", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcGalleryDownloadManifestResponse)
}
func (h *ClientCommandsHandlerProxy) GalleryDownloadIndex(ctx context.Context, req *pb.RpcGalleryDownloadIndexRequest) *pb.RpcGalleryDownloadIndexResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.GalleryDownloadIndex(ctx, req.(*pb.RpcGalleryDownloadIndexRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "GalleryDownloadIndex", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcGalleryDownloadIndexResponse)
}
func (h *ClientCommandsHandlerProxy) BlockUpload(ctx context.Context, req *pb.RpcBlockUploadRequest) *pb.RpcBlockUploadResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockUpload(ctx, req.(*pb.RpcBlockUploadRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockUpload", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockUploadResponse)
}
func (h *ClientCommandsHandlerProxy) BlockReplace(ctx context.Context, req *pb.RpcBlockReplaceRequest) *pb.RpcBlockReplaceResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockReplace(ctx, req.(*pb.RpcBlockReplaceRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockReplace", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockReplaceResponse)
}
func (h *ClientCommandsHandlerProxy) BlockCreate(ctx context.Context, req *pb.RpcBlockCreateRequest) *pb.RpcBlockCreateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockCreate(ctx, req.(*pb.RpcBlockCreateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockCreate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockCreateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockSplit(ctx context.Context, req *pb.RpcBlockSplitRequest) *pb.RpcBlockSplitResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockSplit(ctx, req.(*pb.RpcBlockSplitRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockSplit", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockSplitResponse)
}
func (h *ClientCommandsHandlerProxy) BlockMerge(ctx context.Context, req *pb.RpcBlockMergeRequest) *pb.RpcBlockMergeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockMerge(ctx, req.(*pb.RpcBlockMergeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockMerge", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockMergeResponse)
}
func (h *ClientCommandsHandlerProxy) BlockCopy(ctx context.Context, req *pb.RpcBlockCopyRequest) *pb.RpcBlockCopyResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockCopy(ctx, req.(*pb.RpcBlockCopyRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockCopy", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockCopyResponse)
}
func (h *ClientCommandsHandlerProxy) BlockPaste(ctx context.Context, req *pb.RpcBlockPasteRequest) *pb.RpcBlockPasteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockPaste(ctx, req.(*pb.RpcBlockPasteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockPaste", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockPasteResponse)
}
func (h *ClientCommandsHandlerProxy) BlockCut(ctx context.Context, req *pb.RpcBlockCutRequest) *pb.RpcBlockCutResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockCut(ctx, req.(*pb.RpcBlockCutRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockCut", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockCutResponse)
}
func (h *ClientCommandsHandlerProxy) BlockSetFields(ctx context.Context, req *pb.RpcBlockSetFieldsRequest) *pb.RpcBlockSetFieldsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockSetFields(ctx, req.(*pb.RpcBlockSetFieldsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockSetFields", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockSetFieldsResponse)
}
func (h *ClientCommandsHandlerProxy) BlockExport(ctx context.Context, req *pb.RpcBlockExportRequest) *pb.RpcBlockExportResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockExport(ctx, req.(*pb.RpcBlockExportRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockExport", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockExportResponse)
}
func (h *ClientCommandsHandlerProxy) BlockSetCarriage(ctx context.Context, req *pb.RpcBlockSetCarriageRequest) *pb.RpcBlockSetCarriageResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockSetCarriage(ctx, req.(*pb.RpcBlockSetCarriageRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockSetCarriage", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockSetCarriageResponse)
}
func (h *ClientCommandsHandlerProxy) BlockPreview(ctx context.Context, req *pb.RpcBlockPreviewRequest) *pb.RpcBlockPreviewResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockPreview(ctx, req.(*pb.RpcBlockPreviewRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockPreview", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockPreviewResponse)
}
func (h *ClientCommandsHandlerProxy) BlockListDelete(ctx context.Context, req *pb.RpcBlockListDeleteRequest) *pb.RpcBlockListDeleteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockListDelete(ctx, req.(*pb.RpcBlockListDeleteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockListDelete", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockListDeleteResponse)
}
func (h *ClientCommandsHandlerProxy) BlockListMoveToExistingObject(ctx context.Context, req *pb.RpcBlockListMoveToExistingObjectRequest) *pb.RpcBlockListMoveToExistingObjectResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockListMoveToExistingObject(ctx, req.(*pb.RpcBlockListMoveToExistingObjectRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockListMoveToExistingObject", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockListMoveToExistingObjectResponse)
}
func (h *ClientCommandsHandlerProxy) BlockListMoveToNewObject(ctx context.Context, req *pb.RpcBlockListMoveToNewObjectRequest) *pb.RpcBlockListMoveToNewObjectResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockListMoveToNewObject(ctx, req.(*pb.RpcBlockListMoveToNewObjectRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockListMoveToNewObject", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockListMoveToNewObjectResponse)
}
func (h *ClientCommandsHandlerProxy) BlockListConvertToObjects(ctx context.Context, req *pb.RpcBlockListConvertToObjectsRequest) *pb.RpcBlockListConvertToObjectsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockListConvertToObjects(ctx, req.(*pb.RpcBlockListConvertToObjectsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockListConvertToObjects", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockListConvertToObjectsResponse)
}
func (h *ClientCommandsHandlerProxy) BlockListSetFields(ctx context.Context, req *pb.RpcBlockListSetFieldsRequest) *pb.RpcBlockListSetFieldsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockListSetFields(ctx, req.(*pb.RpcBlockListSetFieldsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockListSetFields", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockListSetFieldsResponse)
}
func (h *ClientCommandsHandlerProxy) BlockListDuplicate(ctx context.Context, req *pb.RpcBlockListDuplicateRequest) *pb.RpcBlockListDuplicateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockListDuplicate(ctx, req.(*pb.RpcBlockListDuplicateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockListDuplicate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockListDuplicateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockListSetBackgroundColor(ctx context.Context, req *pb.RpcBlockListSetBackgroundColorRequest) *pb.RpcBlockListSetBackgroundColorResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockListSetBackgroundColor(ctx, req.(*pb.RpcBlockListSetBackgroundColorRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockListSetBackgroundColor", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockListSetBackgroundColorResponse)
}
func (h *ClientCommandsHandlerProxy) BlockListSetAlign(ctx context.Context, req *pb.RpcBlockListSetAlignRequest) *pb.RpcBlockListSetAlignResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockListSetAlign(ctx, req.(*pb.RpcBlockListSetAlignRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockListSetAlign", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockListSetAlignResponse)
}
func (h *ClientCommandsHandlerProxy) BlockListSetVerticalAlign(ctx context.Context, req *pb.RpcBlockListSetVerticalAlignRequest) *pb.RpcBlockListSetVerticalAlignResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockListSetVerticalAlign(ctx, req.(*pb.RpcBlockListSetVerticalAlignRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockListSetVerticalAlign", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockListSetVerticalAlignResponse)
}
func (h *ClientCommandsHandlerProxy) BlockListTurnInto(ctx context.Context, req *pb.RpcBlockListTurnIntoRequest) *pb.RpcBlockListTurnIntoResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockListTurnInto(ctx, req.(*pb.RpcBlockListTurnIntoRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockListTurnInto", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockListTurnIntoResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTextSetText(ctx context.Context, req *pb.RpcBlockTextSetTextRequest) *pb.RpcBlockTextSetTextResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTextSetText(ctx, req.(*pb.RpcBlockTextSetTextRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTextSetText", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTextSetTextResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTextSetColor(ctx context.Context, req *pb.RpcBlockTextSetColorRequest) *pb.RpcBlockTextSetColorResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTextSetColor(ctx, req.(*pb.RpcBlockTextSetColorRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTextSetColor", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTextSetColorResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTextSetStyle(ctx context.Context, req *pb.RpcBlockTextSetStyleRequest) *pb.RpcBlockTextSetStyleResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTextSetStyle(ctx, req.(*pb.RpcBlockTextSetStyleRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTextSetStyle", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTextSetStyleResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTextSetChecked(ctx context.Context, req *pb.RpcBlockTextSetCheckedRequest) *pb.RpcBlockTextSetCheckedResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTextSetChecked(ctx, req.(*pb.RpcBlockTextSetCheckedRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTextSetChecked", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTextSetCheckedResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTextSetIcon(ctx context.Context, req *pb.RpcBlockTextSetIconRequest) *pb.RpcBlockTextSetIconResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTextSetIcon(ctx, req.(*pb.RpcBlockTextSetIconRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTextSetIcon", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTextSetIconResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTextListSetColor(ctx context.Context, req *pb.RpcBlockTextListSetColorRequest) *pb.RpcBlockTextListSetColorResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTextListSetColor(ctx, req.(*pb.RpcBlockTextListSetColorRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTextListSetColor", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTextListSetColorResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTextListSetMark(ctx context.Context, req *pb.RpcBlockTextListSetMarkRequest) *pb.RpcBlockTextListSetMarkResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTextListSetMark(ctx, req.(*pb.RpcBlockTextListSetMarkRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTextListSetMark", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTextListSetMarkResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTextListSetStyle(ctx context.Context, req *pb.RpcBlockTextListSetStyleRequest) *pb.RpcBlockTextListSetStyleResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTextListSetStyle(ctx, req.(*pb.RpcBlockTextListSetStyleRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTextListSetStyle", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTextListSetStyleResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTextListClearStyle(ctx context.Context, req *pb.RpcBlockTextListClearStyleRequest) *pb.RpcBlockTextListClearStyleResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTextListClearStyle(ctx, req.(*pb.RpcBlockTextListClearStyleRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTextListClearStyle", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTextListClearStyleResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTextListClearContent(ctx context.Context, req *pb.RpcBlockTextListClearContentRequest) *pb.RpcBlockTextListClearContentResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTextListClearContent(ctx, req.(*pb.RpcBlockTextListClearContentRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTextListClearContent", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTextListClearContentResponse)
}
func (h *ClientCommandsHandlerProxy) BlockFileSetName(ctx context.Context, req *pb.RpcBlockFileSetNameRequest) *pb.RpcBlockFileSetNameResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockFileSetName(ctx, req.(*pb.RpcBlockFileSetNameRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockFileSetName", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockFileSetNameResponse)
}
func (h *ClientCommandsHandlerProxy) BlockFileSetTargetObjectId(ctx context.Context, req *pb.RpcBlockFileSetTargetObjectIdRequest) *pb.RpcBlockFileSetTargetObjectIdResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockFileSetTargetObjectId(ctx, req.(*pb.RpcBlockFileSetTargetObjectIdRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockFileSetTargetObjectId", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockFileSetTargetObjectIdResponse)
}
func (h *ClientCommandsHandlerProxy) BlockImageSetName(ctx context.Context, req *pb.RpcBlockImageSetNameRequest) *pb.RpcBlockImageSetNameResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockImageSetName(ctx, req.(*pb.RpcBlockImageSetNameRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockImageSetName", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockImageSetNameResponse)
}
func (h *ClientCommandsHandlerProxy) BlockVideoSetName(ctx context.Context, req *pb.RpcBlockVideoSetNameRequest) *pb.RpcBlockVideoSetNameResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockVideoSetName(ctx, req.(*pb.RpcBlockVideoSetNameRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockVideoSetName", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockVideoSetNameResponse)
}
func (h *ClientCommandsHandlerProxy) BlockFileCreateAndUpload(ctx context.Context, req *pb.RpcBlockFileCreateAndUploadRequest) *pb.RpcBlockFileCreateAndUploadResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockFileCreateAndUpload(ctx, req.(*pb.RpcBlockFileCreateAndUploadRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockFileCreateAndUpload", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockFileCreateAndUploadResponse)
}
func (h *ClientCommandsHandlerProxy) BlockFileListSetStyle(ctx context.Context, req *pb.RpcBlockFileListSetStyleRequest) *pb.RpcBlockFileListSetStyleResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockFileListSetStyle(ctx, req.(*pb.RpcBlockFileListSetStyleRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockFileListSetStyle", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockFileListSetStyleResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewViewCreate(ctx context.Context, req *pb.RpcBlockDataviewViewCreateRequest) *pb.RpcBlockDataviewViewCreateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewViewCreate(ctx, req.(*pb.RpcBlockDataviewViewCreateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewViewCreate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewViewCreateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewViewDelete(ctx context.Context, req *pb.RpcBlockDataviewViewDeleteRequest) *pb.RpcBlockDataviewViewDeleteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewViewDelete(ctx, req.(*pb.RpcBlockDataviewViewDeleteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewViewDelete", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewViewDeleteResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewViewUpdate(ctx context.Context, req *pb.RpcBlockDataviewViewUpdateRequest) *pb.RpcBlockDataviewViewUpdateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewViewUpdate(ctx, req.(*pb.RpcBlockDataviewViewUpdateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewViewUpdate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewViewUpdateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewViewSetActive(ctx context.Context, req *pb.RpcBlockDataviewViewSetActiveRequest) *pb.RpcBlockDataviewViewSetActiveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewViewSetActive(ctx, req.(*pb.RpcBlockDataviewViewSetActiveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewViewSetActive", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewViewSetActiveResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewViewSetPosition(ctx context.Context, req *pb.RpcBlockDataviewViewSetPositionRequest) *pb.RpcBlockDataviewViewSetPositionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewViewSetPosition(ctx, req.(*pb.RpcBlockDataviewViewSetPositionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewViewSetPosition", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewViewSetPositionResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewSetSource(ctx context.Context, req *pb.RpcBlockDataviewSetSourceRequest) *pb.RpcBlockDataviewSetSourceResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewSetSource(ctx, req.(*pb.RpcBlockDataviewSetSourceRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewSetSource", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewSetSourceResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewRelationSet(ctx context.Context, req *pb.RpcBlockDataviewRelationSetRequest) *pb.RpcBlockDataviewRelationSetResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewRelationSet(ctx, req.(*pb.RpcBlockDataviewRelationSetRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewRelationSet", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewRelationSetResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewRelationAdd(ctx context.Context, req *pb.RpcBlockDataviewRelationAddRequest) *pb.RpcBlockDataviewRelationAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewRelationAdd(ctx, req.(*pb.RpcBlockDataviewRelationAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewRelationAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewRelationAddResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewRelationDelete(ctx context.Context, req *pb.RpcBlockDataviewRelationDeleteRequest) *pb.RpcBlockDataviewRelationDeleteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewRelationDelete(ctx, req.(*pb.RpcBlockDataviewRelationDeleteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewRelationDelete", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewRelationDeleteResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewGroupOrderUpdate(ctx context.Context, req *pb.RpcBlockDataviewGroupOrderUpdateRequest) *pb.RpcBlockDataviewGroupOrderUpdateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewGroupOrderUpdate(ctx, req.(*pb.RpcBlockDataviewGroupOrderUpdateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewGroupOrderUpdate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewGroupOrderUpdateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewObjectOrderUpdate(ctx context.Context, req *pb.RpcBlockDataviewObjectOrderUpdateRequest) *pb.RpcBlockDataviewObjectOrderUpdateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewObjectOrderUpdate(ctx, req.(*pb.RpcBlockDataviewObjectOrderUpdateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewObjectOrderUpdate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewObjectOrderUpdateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewObjectOrderMove(ctx context.Context, req *pb.RpcBlockDataviewObjectOrderMoveRequest) *pb.RpcBlockDataviewObjectOrderMoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewObjectOrderMove(ctx, req.(*pb.RpcBlockDataviewObjectOrderMoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewObjectOrderMove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewObjectOrderMoveResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewCreateFromExistingObject(ctx context.Context, req *pb.RpcBlockDataviewCreateFromExistingObjectRequest) *pb.RpcBlockDataviewCreateFromExistingObjectResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewCreateFromExistingObject(ctx, req.(*pb.RpcBlockDataviewCreateFromExistingObjectRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewCreateFromExistingObject", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewCreateFromExistingObjectResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewFilterAdd(ctx context.Context, req *pb.RpcBlockDataviewFilterAddRequest) *pb.RpcBlockDataviewFilterAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewFilterAdd(ctx, req.(*pb.RpcBlockDataviewFilterAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewFilterAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewFilterAddResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewFilterRemove(ctx context.Context, req *pb.RpcBlockDataviewFilterRemoveRequest) *pb.RpcBlockDataviewFilterRemoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewFilterRemove(ctx, req.(*pb.RpcBlockDataviewFilterRemoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewFilterRemove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewFilterRemoveResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewFilterReplace(ctx context.Context, req *pb.RpcBlockDataviewFilterReplaceRequest) *pb.RpcBlockDataviewFilterReplaceResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewFilterReplace(ctx, req.(*pb.RpcBlockDataviewFilterReplaceRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewFilterReplace", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewFilterReplaceResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewFilterSort(ctx context.Context, req *pb.RpcBlockDataviewFilterSortRequest) *pb.RpcBlockDataviewFilterSortResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewFilterSort(ctx, req.(*pb.RpcBlockDataviewFilterSortRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewFilterSort", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewFilterSortResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewSortAdd(ctx context.Context, req *pb.RpcBlockDataviewSortAddRequest) *pb.RpcBlockDataviewSortAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewSortAdd(ctx, req.(*pb.RpcBlockDataviewSortAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewSortAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewSortAddResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewSortRemove(ctx context.Context, req *pb.RpcBlockDataviewSortRemoveRequest) *pb.RpcBlockDataviewSortRemoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewSortRemove(ctx, req.(*pb.RpcBlockDataviewSortRemoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewSortRemove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewSortRemoveResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewSortReplace(ctx context.Context, req *pb.RpcBlockDataviewSortReplaceRequest) *pb.RpcBlockDataviewSortReplaceResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewSortReplace(ctx, req.(*pb.RpcBlockDataviewSortReplaceRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewSortReplace", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewSortReplaceResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewSortSort(ctx context.Context, req *pb.RpcBlockDataviewSortSSortRequest) *pb.RpcBlockDataviewSortSSortResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewSortSort(ctx, req.(*pb.RpcBlockDataviewSortSSortRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewSortSort", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewSortSSortResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewViewRelationAdd(ctx context.Context, req *pb.RpcBlockDataviewViewRelationAddRequest) *pb.RpcBlockDataviewViewRelationAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewViewRelationAdd(ctx, req.(*pb.RpcBlockDataviewViewRelationAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewViewRelationAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewViewRelationAddResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewViewRelationRemove(ctx context.Context, req *pb.RpcBlockDataviewViewRelationRemoveRequest) *pb.RpcBlockDataviewViewRelationRemoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewViewRelationRemove(ctx, req.(*pb.RpcBlockDataviewViewRelationRemoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewViewRelationRemove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewViewRelationRemoveResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewViewRelationReplace(ctx context.Context, req *pb.RpcBlockDataviewViewRelationReplaceRequest) *pb.RpcBlockDataviewViewRelationReplaceResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewViewRelationReplace(ctx, req.(*pb.RpcBlockDataviewViewRelationReplaceRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewViewRelationReplace", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewViewRelationReplaceResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDataviewViewRelationSort(ctx context.Context, req *pb.RpcBlockDataviewViewRelationSortRequest) *pb.RpcBlockDataviewViewRelationSortResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDataviewViewRelationSort(ctx, req.(*pb.RpcBlockDataviewViewRelationSortRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDataviewViewRelationSort", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDataviewViewRelationSortResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableCreate(ctx context.Context, req *pb.RpcBlockTableCreateRequest) *pb.RpcBlockTableCreateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableCreate(ctx, req.(*pb.RpcBlockTableCreateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableCreate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableCreateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableExpand(ctx context.Context, req *pb.RpcBlockTableExpandRequest) *pb.RpcBlockTableExpandResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableExpand(ctx, req.(*pb.RpcBlockTableExpandRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableExpand", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableExpandResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableRowCreate(ctx context.Context, req *pb.RpcBlockTableRowCreateRequest) *pb.RpcBlockTableRowCreateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableRowCreate(ctx, req.(*pb.RpcBlockTableRowCreateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableRowCreate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableRowCreateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableRowDelete(ctx context.Context, req *pb.RpcBlockTableRowDeleteRequest) *pb.RpcBlockTableRowDeleteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableRowDelete(ctx, req.(*pb.RpcBlockTableRowDeleteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableRowDelete", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableRowDeleteResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableRowDuplicate(ctx context.Context, req *pb.RpcBlockTableRowDuplicateRequest) *pb.RpcBlockTableRowDuplicateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableRowDuplicate(ctx, req.(*pb.RpcBlockTableRowDuplicateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableRowDuplicate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableRowDuplicateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableRowSetHeader(ctx context.Context, req *pb.RpcBlockTableRowSetHeaderRequest) *pb.RpcBlockTableRowSetHeaderResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableRowSetHeader(ctx, req.(*pb.RpcBlockTableRowSetHeaderRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableRowSetHeader", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableRowSetHeaderResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableColumnCreate(ctx context.Context, req *pb.RpcBlockTableColumnCreateRequest) *pb.RpcBlockTableColumnCreateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableColumnCreate(ctx, req.(*pb.RpcBlockTableColumnCreateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableColumnCreate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableColumnCreateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableColumnMove(ctx context.Context, req *pb.RpcBlockTableColumnMoveRequest) *pb.RpcBlockTableColumnMoveResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableColumnMove(ctx, req.(*pb.RpcBlockTableColumnMoveRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableColumnMove", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableColumnMoveResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableColumnDelete(ctx context.Context, req *pb.RpcBlockTableColumnDeleteRequest) *pb.RpcBlockTableColumnDeleteResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableColumnDelete(ctx, req.(*pb.RpcBlockTableColumnDeleteRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableColumnDelete", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableColumnDeleteResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableColumnDuplicate(ctx context.Context, req *pb.RpcBlockTableColumnDuplicateRequest) *pb.RpcBlockTableColumnDuplicateResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableColumnDuplicate(ctx, req.(*pb.RpcBlockTableColumnDuplicateRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableColumnDuplicate", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableColumnDuplicateResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableRowListFill(ctx context.Context, req *pb.RpcBlockTableRowListFillRequest) *pb.RpcBlockTableRowListFillResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableRowListFill(ctx, req.(*pb.RpcBlockTableRowListFillRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableRowListFill", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableRowListFillResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableRowListClean(ctx context.Context, req *pb.RpcBlockTableRowListCleanRequest) *pb.RpcBlockTableRowListCleanResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableRowListClean(ctx, req.(*pb.RpcBlockTableRowListCleanRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableRowListClean", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableRowListCleanResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableColumnListFill(ctx context.Context, req *pb.RpcBlockTableColumnListFillRequest) *pb.RpcBlockTableColumnListFillResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableColumnListFill(ctx, req.(*pb.RpcBlockTableColumnListFillRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableColumnListFill", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableColumnListFillResponse)
}
func (h *ClientCommandsHandlerProxy) BlockTableSort(ctx context.Context, req *pb.RpcBlockTableSortRequest) *pb.RpcBlockTableSortResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockTableSort(ctx, req.(*pb.RpcBlockTableSortRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockTableSort", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockTableSortResponse)
}
func (h *ClientCommandsHandlerProxy) BlockCreateWidget(ctx context.Context, req *pb.RpcBlockCreateWidgetRequest) *pb.RpcBlockCreateWidgetResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockCreateWidget(ctx, req.(*pb.RpcBlockCreateWidgetRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockCreateWidget", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockCreateWidgetResponse)
}
func (h *ClientCommandsHandlerProxy) BlockWidgetSetTargetId(ctx context.Context, req *pb.RpcBlockWidgetSetTargetIdRequest) *pb.RpcBlockWidgetSetTargetIdResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockWidgetSetTargetId(ctx, req.(*pb.RpcBlockWidgetSetTargetIdRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockWidgetSetTargetId", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockWidgetSetTargetIdResponse)
}
func (h *ClientCommandsHandlerProxy) BlockWidgetSetLayout(ctx context.Context, req *pb.RpcBlockWidgetSetLayoutRequest) *pb.RpcBlockWidgetSetLayoutResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockWidgetSetLayout(ctx, req.(*pb.RpcBlockWidgetSetLayoutRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockWidgetSetLayout", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockWidgetSetLayoutResponse)
}
func (h *ClientCommandsHandlerProxy) BlockWidgetSetLimit(ctx context.Context, req *pb.RpcBlockWidgetSetLimitRequest) *pb.RpcBlockWidgetSetLimitResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockWidgetSetLimit(ctx, req.(*pb.RpcBlockWidgetSetLimitRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockWidgetSetLimit", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockWidgetSetLimitResponse)
}
func (h *ClientCommandsHandlerProxy) BlockWidgetSetViewId(ctx context.Context, req *pb.RpcBlockWidgetSetViewIdRequest) *pb.RpcBlockWidgetSetViewIdResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockWidgetSetViewId(ctx, req.(*pb.RpcBlockWidgetSetViewIdRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockWidgetSetViewId", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockWidgetSetViewIdResponse)
}
func (h *ClientCommandsHandlerProxy) BlockLinkCreateWithObject(ctx context.Context, req *pb.RpcBlockLinkCreateWithObjectRequest) *pb.RpcBlockLinkCreateWithObjectResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockLinkCreateWithObject(ctx, req.(*pb.RpcBlockLinkCreateWithObjectRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockLinkCreateWithObject", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockLinkCreateWithObjectResponse)
}
func (h *ClientCommandsHandlerProxy) BlockLinkListSetAppearance(ctx context.Context, req *pb.RpcBlockLinkListSetAppearanceRequest) *pb.RpcBlockLinkListSetAppearanceResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockLinkListSetAppearance(ctx, req.(*pb.RpcBlockLinkListSetAppearanceRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockLinkListSetAppearance", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockLinkListSetAppearanceResponse)
}
func (h *ClientCommandsHandlerProxy) BlockBookmarkFetch(ctx context.Context, req *pb.RpcBlockBookmarkFetchRequest) *pb.RpcBlockBookmarkFetchResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockBookmarkFetch(ctx, req.(*pb.RpcBlockBookmarkFetchRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockBookmarkFetch", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockBookmarkFetchResponse)
}
func (h *ClientCommandsHandlerProxy) BlockBookmarkCreateAndFetch(ctx context.Context, req *pb.RpcBlockBookmarkCreateAndFetchRequest) *pb.RpcBlockBookmarkCreateAndFetchResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockBookmarkCreateAndFetch(ctx, req.(*pb.RpcBlockBookmarkCreateAndFetchRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockBookmarkCreateAndFetch", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockBookmarkCreateAndFetchResponse)
}
func (h *ClientCommandsHandlerProxy) BlockRelationSetKey(ctx context.Context, req *pb.RpcBlockRelationSetKeyRequest) *pb.RpcBlockRelationSetKeyResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockRelationSetKey(ctx, req.(*pb.RpcBlockRelationSetKeyRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockRelationSetKey", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockRelationSetKeyResponse)
}
func (h *ClientCommandsHandlerProxy) BlockRelationAdd(ctx context.Context, req *pb.RpcBlockRelationAddRequest) *pb.RpcBlockRelationAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockRelationAdd(ctx, req.(*pb.RpcBlockRelationAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockRelationAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockRelationAddResponse)
}
func (h *ClientCommandsHandlerProxy) BlockDivListSetStyle(ctx context.Context, req *pb.RpcBlockDivListSetStyleRequest) *pb.RpcBlockDivListSetStyleResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockDivListSetStyle(ctx, req.(*pb.RpcBlockDivListSetStyleRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockDivListSetStyle", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockDivListSetStyleResponse)
}
func (h *ClientCommandsHandlerProxy) BlockLatexSetText(ctx context.Context, req *pb.RpcBlockLatexSetTextRequest) *pb.RpcBlockLatexSetTextResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BlockLatexSetText(ctx, req.(*pb.RpcBlockLatexSetTextRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BlockLatexSetText", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBlockLatexSetTextResponse)
}
func (h *ClientCommandsHandlerProxy) ProcessCancel(ctx context.Context, req *pb.RpcProcessCancelRequest) *pb.RpcProcessCancelResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ProcessCancel(ctx, req.(*pb.RpcProcessCancelRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ProcessCancel", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcProcessCancelResponse)
}
func (h *ClientCommandsHandlerProxy) ProcessSubscribe(ctx context.Context, req *pb.RpcProcessSubscribeRequest) *pb.RpcProcessSubscribeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ProcessSubscribe(ctx, req.(*pb.RpcProcessSubscribeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ProcessSubscribe", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcProcessSubscribeResponse)
}
func (h *ClientCommandsHandlerProxy) ProcessUnsubscribe(ctx context.Context, req *pb.RpcProcessUnsubscribeRequest) *pb.RpcProcessUnsubscribeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ProcessUnsubscribe(ctx, req.(*pb.RpcProcessUnsubscribeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ProcessUnsubscribe", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcProcessUnsubscribeResponse)
}
func (h *ClientCommandsHandlerProxy) LogSend(ctx context.Context, req *pb.RpcLogSendRequest) *pb.RpcLogSendResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.LogSend(ctx, req.(*pb.RpcLogSendRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "LogSend", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcLogSendResponse)
}
func (h *ClientCommandsHandlerProxy) DebugStat(ctx context.Context, req *pb.RpcDebugStatRequest) *pb.RpcDebugStatResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugStat(ctx, req.(*pb.RpcDebugStatRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugStat", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugStatResponse)
}
func (h *ClientCommandsHandlerProxy) DebugTree(ctx context.Context, req *pb.RpcDebugTreeRequest) *pb.RpcDebugTreeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugTree(ctx, req.(*pb.RpcDebugTreeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugTree", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugTreeResponse)
}
func (h *ClientCommandsHandlerProxy) DebugTreeHeads(ctx context.Context, req *pb.RpcDebugTreeHeadsRequest) *pb.RpcDebugTreeHeadsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugTreeHeads(ctx, req.(*pb.RpcDebugTreeHeadsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugTreeHeads", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugTreeHeadsResponse)
}
func (h *ClientCommandsHandlerProxy) DebugSpaceSummary(ctx context.Context, req *pb.RpcDebugSpaceSummaryRequest) *pb.RpcDebugSpaceSummaryResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugSpaceSummary(ctx, req.(*pb.RpcDebugSpaceSummaryRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugSpaceSummary", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugSpaceSummaryResponse)
}
func (h *ClientCommandsHandlerProxy) DebugStackGoroutines(ctx context.Context, req *pb.RpcDebugStackGoroutinesRequest) *pb.RpcDebugStackGoroutinesResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugStackGoroutines(ctx, req.(*pb.RpcDebugStackGoroutinesRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugStackGoroutines", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugStackGoroutinesResponse)
}
func (h *ClientCommandsHandlerProxy) DebugExportLocalstore(ctx context.Context, req *pb.RpcDebugExportLocalstoreRequest) *pb.RpcDebugExportLocalstoreResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugExportLocalstore(ctx, req.(*pb.RpcDebugExportLocalstoreRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugExportLocalstore", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugExportLocalstoreResponse)
}
func (h *ClientCommandsHandlerProxy) DebugPing(ctx context.Context, req *pb.RpcDebugPingRequest) *pb.RpcDebugPingResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugPing(ctx, req.(*pb.RpcDebugPingRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugPing", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugPingResponse)
}
func (h *ClientCommandsHandlerProxy) DebugSubscriptions(ctx context.Context, req *pb.RpcDebugSubscriptionsRequest) *pb.RpcDebugSubscriptionsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugSubscriptions(ctx, req.(*pb.RpcDebugSubscriptionsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugSubscriptions", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugSubscriptionsResponse)
}
func (h *ClientCommandsHandlerProxy) DebugOpenedObjects(ctx context.Context, req *pb.RpcDebugOpenedObjectsRequest) *pb.RpcDebugOpenedObjectsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugOpenedObjects(ctx, req.(*pb.RpcDebugOpenedObjectsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugOpenedObjects", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugOpenedObjectsResponse)
}
func (h *ClientCommandsHandlerProxy) DebugRunProfiler(ctx context.Context, req *pb.RpcDebugRunProfilerRequest) *pb.RpcDebugRunProfilerResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugRunProfiler(ctx, req.(*pb.RpcDebugRunProfilerRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugRunProfiler", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugRunProfilerResponse)
}
func (h *ClientCommandsHandlerProxy) DebugAccountSelectTrace(ctx context.Context, req *pb.RpcDebugAccountSelectTraceRequest) *pb.RpcDebugAccountSelectTraceResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugAccountSelectTrace(ctx, req.(*pb.RpcDebugAccountSelectTraceRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugAccountSelectTrace", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugAccountSelectTraceResponse)
}
func (h *ClientCommandsHandlerProxy) DebugAnystoreObjectChanges(ctx context.Context, req *pb.RpcDebugAnystoreObjectChangesRequest) *pb.RpcDebugAnystoreObjectChangesResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugAnystoreObjectChanges(ctx, req.(*pb.RpcDebugAnystoreObjectChangesRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugAnystoreObjectChanges", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugAnystoreObjectChangesResponse)
}
func (h *ClientCommandsHandlerProxy) DebugNetCheck(ctx context.Context, req *pb.RpcDebugNetCheckRequest) *pb.RpcDebugNetCheckResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugNetCheck(ctx, req.(*pb.RpcDebugNetCheckRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugNetCheck", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugNetCheckResponse)
}
func (h *ClientCommandsHandlerProxy) DebugExportLog(ctx context.Context, req *pb.RpcDebugExportLogRequest) *pb.RpcDebugExportLogResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DebugExportLog(ctx, req.(*pb.RpcDebugExportLogRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DebugExportLog", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDebugExportLogResponse)
}
func (h *ClientCommandsHandlerProxy) InitialSetParameters(ctx context.Context, req *pb.RpcInitialSetParametersRequest) *pb.RpcInitialSetParametersResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.InitialSetParameters(ctx, req.(*pb.RpcInitialSetParametersRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "InitialSetParameters", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcInitialSetParametersResponse)
}
func (h *ClientCommandsHandlerProxy) NotificationList(ctx context.Context, req *pb.RpcNotificationListRequest) *pb.RpcNotificationListResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.NotificationList(ctx, req.(*pb.RpcNotificationListRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "NotificationList", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcNotificationListResponse)
}
func (h *ClientCommandsHandlerProxy) NotificationReply(ctx context.Context, req *pb.RpcNotificationReplyRequest) *pb.RpcNotificationReplyResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.NotificationReply(ctx, req.(*pb.RpcNotificationReplyRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "NotificationReply", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcNotificationReplyResponse)
}
func (h *ClientCommandsHandlerProxy) NotificationTest(ctx context.Context, req *pb.RpcNotificationTestRequest) *pb.RpcNotificationTestResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.NotificationTest(ctx, req.(*pb.RpcNotificationTestRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "NotificationTest", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcNotificationTestResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipGetStatus(ctx context.Context, req *pb.RpcMembershipGetStatusRequest) *pb.RpcMembershipGetStatusResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipGetStatus(ctx, req.(*pb.RpcMembershipGetStatusRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipGetStatus", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipGetStatusResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipIsNameValid(ctx context.Context, req *pb.RpcMembershipIsNameValidRequest) *pb.RpcMembershipIsNameValidResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipIsNameValid(ctx, req.(*pb.RpcMembershipIsNameValidRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipIsNameValid", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipIsNameValidResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipRegisterPaymentRequest(ctx context.Context, req *pb.RpcMembershipRegisterPaymentRequestRequest) *pb.RpcMembershipRegisterPaymentRequestResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipRegisterPaymentRequest(ctx, req.(*pb.RpcMembershipRegisterPaymentRequestRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipRegisterPaymentRequest", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipRegisterPaymentRequestResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipGetPortalLinkUrl(ctx context.Context, req *pb.RpcMembershipGetPortalLinkUrlRequest) *pb.RpcMembershipGetPortalLinkUrlResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipGetPortalLinkUrl(ctx, req.(*pb.RpcMembershipGetPortalLinkUrlRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipGetPortalLinkUrl", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipGetPortalLinkUrlResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipGetVerificationEmailStatus(ctx context.Context, req *pb.RpcMembershipGetVerificationEmailStatusRequest) *pb.RpcMembershipGetVerificationEmailStatusResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipGetVerificationEmailStatus(ctx, req.(*pb.RpcMembershipGetVerificationEmailStatusRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipGetVerificationEmailStatus", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipGetVerificationEmailStatusResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipGetVerificationEmail(ctx context.Context, req *pb.RpcMembershipGetVerificationEmailRequest) *pb.RpcMembershipGetVerificationEmailResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipGetVerificationEmail(ctx, req.(*pb.RpcMembershipGetVerificationEmailRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipGetVerificationEmail", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipGetVerificationEmailResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipVerifyEmailCode(ctx context.Context, req *pb.RpcMembershipVerifyEmailCodeRequest) *pb.RpcMembershipVerifyEmailCodeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipVerifyEmailCode(ctx, req.(*pb.RpcMembershipVerifyEmailCodeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipVerifyEmailCode", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipVerifyEmailCodeResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipFinalize(ctx context.Context, req *pb.RpcMembershipFinalizeRequest) *pb.RpcMembershipFinalizeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipFinalize(ctx, req.(*pb.RpcMembershipFinalizeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipFinalize", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipFinalizeResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipGetTiers(ctx context.Context, req *pb.RpcMembershipGetTiersRequest) *pb.RpcMembershipGetTiersResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipGetTiers(ctx, req.(*pb.RpcMembershipGetTiersRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipGetTiers", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipGetTiersResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipVerifyAppStoreReceipt(ctx context.Context, req *pb.RpcMembershipVerifyAppStoreReceiptRequest) *pb.RpcMembershipVerifyAppStoreReceiptResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipVerifyAppStoreReceipt(ctx, req.(*pb.RpcMembershipVerifyAppStoreReceiptRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipVerifyAppStoreReceipt", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipVerifyAppStoreReceiptResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipCodeGetInfo(ctx context.Context, req *pb.RpcMembershipCodeGetInfoRequest) *pb.RpcMembershipCodeGetInfoResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipCodeGetInfo(ctx, req.(*pb.RpcMembershipCodeGetInfoRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipCodeGetInfo", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipCodeGetInfoResponse)
}
func (h *ClientCommandsHandlerProxy) MembershipCodeRedeem(ctx context.Context, req *pb.RpcMembershipCodeRedeemRequest) *pb.RpcMembershipCodeRedeemResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.MembershipCodeRedeem(ctx, req.(*pb.RpcMembershipCodeRedeemRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "MembershipCodeRedeem", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcMembershipCodeRedeemResponse)
}
func (h *ClientCommandsHandlerProxy) NameServiceUserAccountGet(ctx context.Context, req *pb.RpcNameServiceUserAccountGetRequest) *pb.RpcNameServiceUserAccountGetResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.NameServiceUserAccountGet(ctx, req.(*pb.RpcNameServiceUserAccountGetRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "NameServiceUserAccountGet", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcNameServiceUserAccountGetResponse)
}
func (h *ClientCommandsHandlerProxy) NameServiceResolveName(ctx context.Context, req *pb.RpcNameServiceResolveNameRequest) *pb.RpcNameServiceResolveNameResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.NameServiceResolveName(ctx, req.(*pb.RpcNameServiceResolveNameRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "NameServiceResolveName", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcNameServiceResolveNameResponse)
}
func (h *ClientCommandsHandlerProxy) NameServiceResolveAnyId(ctx context.Context, req *pb.RpcNameServiceResolveAnyIdRequest) *pb.RpcNameServiceResolveAnyIdResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.NameServiceResolveAnyId(ctx, req.(*pb.RpcNameServiceResolveAnyIdRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "NameServiceResolveAnyId", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcNameServiceResolveAnyIdResponse)
}
func (h *ClientCommandsHandlerProxy) BroadcastPayloadEvent(ctx context.Context, req *pb.RpcBroadcastPayloadEventRequest) *pb.RpcBroadcastPayloadEventResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.BroadcastPayloadEvent(ctx, req.(*pb.RpcBroadcastPayloadEventRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "BroadcastPayloadEvent", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcBroadcastPayloadEventResponse)
}
func (h *ClientCommandsHandlerProxy) DeviceSetName(ctx context.Context, req *pb.RpcDeviceSetNameRequest) *pb.RpcDeviceSetNameResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DeviceSetName(ctx, req.(*pb.RpcDeviceSetNameRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DeviceSetName", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDeviceSetNameResponse)
}
func (h *ClientCommandsHandlerProxy) DeviceList(ctx context.Context, req *pb.RpcDeviceListRequest) *pb.RpcDeviceListResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DeviceList(ctx, req.(*pb.RpcDeviceListRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DeviceList", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDeviceListResponse)
}
func (h *ClientCommandsHandlerProxy) DeviceNetworkStateSet(ctx context.Context, req *pb.RpcDeviceNetworkStateSetRequest) *pb.RpcDeviceNetworkStateSetResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.DeviceNetworkStateSet(ctx, req.(*pb.RpcDeviceNetworkStateSetRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "DeviceNetworkStateSet", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcDeviceNetworkStateSetResponse)
}
func (h *ClientCommandsHandlerProxy) ChatAddMessage(ctx context.Context, req *pb.RpcChatAddMessageRequest) *pb.RpcChatAddMessageResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatAddMessage(ctx, req.(*pb.RpcChatAddMessageRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatAddMessage", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatAddMessageResponse)
}
func (h *ClientCommandsHandlerProxy) ChatEditMessageContent(ctx context.Context, req *pb.RpcChatEditMessageContentRequest) *pb.RpcChatEditMessageContentResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatEditMessageContent(ctx, req.(*pb.RpcChatEditMessageContentRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatEditMessageContent", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatEditMessageContentResponse)
}
func (h *ClientCommandsHandlerProxy) ChatToggleMessageReaction(ctx context.Context, req *pb.RpcChatToggleMessageReactionRequest) *pb.RpcChatToggleMessageReactionResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatToggleMessageReaction(ctx, req.(*pb.RpcChatToggleMessageReactionRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatToggleMessageReaction", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatToggleMessageReactionResponse)
}
func (h *ClientCommandsHandlerProxy) ChatDeleteMessage(ctx context.Context, req *pb.RpcChatDeleteMessageRequest) *pb.RpcChatDeleteMessageResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatDeleteMessage(ctx, req.(*pb.RpcChatDeleteMessageRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatDeleteMessage", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatDeleteMessageResponse)
}
func (h *ClientCommandsHandlerProxy) ChatGetMessages(ctx context.Context, req *pb.RpcChatGetMessagesRequest) *pb.RpcChatGetMessagesResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatGetMessages(ctx, req.(*pb.RpcChatGetMessagesRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatGetMessages", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatGetMessagesResponse)
}
func (h *ClientCommandsHandlerProxy) ChatGetMessagesByIds(ctx context.Context, req *pb.RpcChatGetMessagesByIdsRequest) *pb.RpcChatGetMessagesByIdsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatGetMessagesByIds(ctx, req.(*pb.RpcChatGetMessagesByIdsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatGetMessagesByIds", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatGetMessagesByIdsResponse)
}
func (h *ClientCommandsHandlerProxy) ChatSubscribeLastMessages(ctx context.Context, req *pb.RpcChatSubscribeLastMessagesRequest) *pb.RpcChatSubscribeLastMessagesResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatSubscribeLastMessages(ctx, req.(*pb.RpcChatSubscribeLastMessagesRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatSubscribeLastMessages", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatSubscribeLastMessagesResponse)
}
func (h *ClientCommandsHandlerProxy) ChatUnsubscribe(ctx context.Context, req *pb.RpcChatUnsubscribeRequest) *pb.RpcChatUnsubscribeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatUnsubscribe(ctx, req.(*pb.RpcChatUnsubscribeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatUnsubscribe", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatUnsubscribeResponse)
}
func (h *ClientCommandsHandlerProxy) ChatReadMessages(ctx context.Context, req *pb.RpcChatReadMessagesRequest) *pb.RpcChatReadMessagesResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatReadMessages(ctx, req.(*pb.RpcChatReadMessagesRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatReadMessages", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatReadMessagesResponse)
}
func (h *ClientCommandsHandlerProxy) ChatUnreadMessages(ctx context.Context, req *pb.RpcChatUnreadRequest) *pb.RpcChatUnreadResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatUnreadMessages(ctx, req.(*pb.RpcChatUnreadRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatUnreadMessages", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatUnreadResponse)
}
func (h *ClientCommandsHandlerProxy) ChatSubscribeToMessagePreviews(ctx context.Context, req *pb.RpcChatSubscribeToMessagePreviewsRequest) *pb.RpcChatSubscribeToMessagePreviewsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatSubscribeToMessagePreviews(ctx, req.(*pb.RpcChatSubscribeToMessagePreviewsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatSubscribeToMessagePreviews", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatSubscribeToMessagePreviewsResponse)
}
func (h *ClientCommandsHandlerProxy) ChatUnsubscribeFromMessagePreviews(ctx context.Context, req *pb.RpcChatUnsubscribeFromMessagePreviewsRequest) *pb.RpcChatUnsubscribeFromMessagePreviewsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatUnsubscribeFromMessagePreviews(ctx, req.(*pb.RpcChatUnsubscribeFromMessagePreviewsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatUnsubscribeFromMessagePreviews", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatUnsubscribeFromMessagePreviewsResponse)
}
func (h *ClientCommandsHandlerProxy) ObjectChatAdd(ctx context.Context, req *pb.RpcObjectChatAddRequest) *pb.RpcObjectChatAddResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ObjectChatAdd(ctx, req.(*pb.RpcObjectChatAddRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ObjectChatAdd", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcObjectChatAddResponse)
}
func (h *ClientCommandsHandlerProxy) ChatReadAll(ctx context.Context, req *pb.RpcChatReadAllRequest) *pb.RpcChatReadAllResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.ChatReadAll(ctx, req.(*pb.RpcChatReadAllRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "ChatReadAll", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcChatReadAllResponse)
}
func (h *ClientCommandsHandlerProxy) AIWritingTools(ctx context.Context, req *pb.RpcAIWritingToolsRequest) *pb.RpcAIWritingToolsResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AIWritingTools(ctx, req.(*pb.RpcAIWritingToolsRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AIWritingTools", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAIWritingToolsResponse)
}
func (h *ClientCommandsHandlerProxy) AIAutofill(ctx context.Context, req *pb.RpcAIAutofillRequest) *pb.RpcAIAutofillResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AIAutofill(ctx, req.(*pb.RpcAIAutofillRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AIAutofill", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAIAutofillResponse)
}
func (h *ClientCommandsHandlerProxy) AIListSummary(ctx context.Context, req *pb.RpcAIListSummaryRequest) *pb.RpcAIListSummaryResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AIListSummary(ctx, req.(*pb.RpcAIListSummaryRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AIListSummary", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAIListSummaryResponse)
}
func (h *ClientCommandsHandlerProxy) AIObjectCreateFromUrl(ctx context.Context, req *pb.RpcAIObjectCreateFromUrlRequest) *pb.RpcAIObjectCreateFromUrlResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.AIObjectCreateFromUrl(ctx, req.(*pb.RpcAIObjectCreateFromUrlRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "AIObjectCreateFromUrl", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcAIObjectCreateFromUrlResponse)
}
func (h *ClientCommandsHandlerProxy) PushNotificationRegisterToken(ctx context.Context, req *pb.RpcPushNotificationRegisterTokenRequest) *pb.RpcPushNotificationRegisterTokenResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.PushNotificationRegisterToken(ctx, req.(*pb.RpcPushNotificationRegisterTokenRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "PushNotificationRegisterToken", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcPushNotificationRegisterTokenResponse)
}
func (h *ClientCommandsHandlerProxy) PushNotificationSetSpaceMode(ctx context.Context, req *pb.RpcPushNotificationSetSpaceModeRequest) *pb.RpcPushNotificationSetSpaceModeResponse {
	actualCall := func(ctx context.Context, req any) (any, error) {
		return h.client.PushNotificationSetSpaceMode(ctx, req.(*pb.RpcPushNotificationSetSpaceModeRequest)), nil
	}
	for _, interceptor := range h.interceptors {
		toCall := actualCall
		currentInterceptor := interceptor
		actualCall = func(ctx context.Context, req any) (any, error) {
			return currentInterceptor(ctx, req, "PushNotificationSetSpaceMode", toCall)
		}
	}
	call, _ := actualCall(ctx, req)
	return call.(*pb.RpcPushNotificationSetSpaceModeResponse)
}
