anytype-heart/clientlibrary/service/service.pb.go

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

package service

import (
	fmt "fmt"
	pb "github.com/anytypeio/go-anytype-middleware/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{
	// 2568 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x9b, 0x5b, 0x6f, 0xdc, 0xc6,
	0x15, 0xc7, 0xb3, 0x40, 0x91, 0xa4, 0x13, 0xe7, 0xc6, 0xd6, 0x8e, 0x23, 0xa7, 0xf2, 0x25, 0x76,
	0x6c, 0xcb, 0x36, 0x6d, 0x4b, 0x6d, 0x8a, 0x5e, 0x03, 0x69, 0x65, 0x2b, 0x42, 0x64, 0x5b, 0xd5,
	0xca, 0x56, 0x11, 0xf4, 0x46, 0x91, 0xc7, 0xbb, 0xcc, 0x72, 0x39, 0x0c, 0x39, 0xbb, 0xf2, 0x16,
	0x28, 0xd0, 0x3b, 0xd0, 0xb7, 0x00, 0x7d, 0xec, 0x4b, 0xfb, 0xda, 0x4f, 0xd2, 0xc7, 0x3c, 0xf6,
	0xb1, 0xb0, 0xbf, 0x48, 0x31, 0xc3, 0xc3, 0x19, 0x72, 0x38, 0x33, 0xcb, 0xf5, 0x43, 0x12, 0x64,
	0xcf, 0xef, 0xfc, 0xcf, 0x19, 0xce, 0xcc, 0xe1, 0x19, 0x92, 0x22, 0xe7, 0xb3, 0xe3, 0xdb, 0x59,
	0x4e, 0x19, 0x2d, 0x6e, 0x17, 0x90, 0xcf, 0xe2, 0x10, 0xaa, 0xff, 0xfa, 0xe2, 0x67, 0xef, 0xb5,
	0x20, 0x9d, 0xb3, 0x79, 0x06, 0x2b, 0x67, 0x15, 0x19, 0xd2, 0xc9, 0x24, 0x48, 0xa3, 0xa2, 0x44,
	0x56, 0xce, 0x28, 0x0b, 0xcc, 0x20, 0x65, 0xf8, 0xfb, 0xfa, 0x3f, 0x9f, 0x92, 0xb7, 0xfa, 0x49,
	0x0c, 0x29, 0xeb, 0xa3, 0x83, 0x77, 0x44, 0x4e, 0x1d, 0x05, 0x49, 0x02, 0xac, 0x9f, 0x43, 0xc0,
	0xc0, 0xbb, 0xe4, 0xa3, 0xbc, 0x7f, 0x90, 0x85, 0x7e, 0x69, 0xf2, 0x4b, 0x9b, 0x7f, 0x00, 0x5f,
	0x4e, 0xa1, 0x60, 0x2b, 0x1f, 0x3a, 0x99, 0x22, 0xa3, 0x69, 0x01, 0xde, 0xe7, 0xe4, 0xcd, 0xd2,
	0x72, 0x00, 0x21, 0x9d, 0x41, 0xee, 0x19, 0xbd, 0xd0, 0x28, 0xa5, 0x2f, 0xbb, 0x21, 0x5d, 0xbb,
	0x4f, 0xd3, 0x19, 0xe4, 0xcc, 0xac, 0x8d, 0x46, 0xb7, 0xb6, 0x82, 0x50, 0xfb, 0x97, 0xe4, 0xad,
	0xcd, 0x30, 0xa4, 0xd3, 0x54, 0x26, 0xde, 0xf4, 0x43, 0x63, 0x2b, 0xf3, 0x2b, 0x0b, 0x28, 0x95,
	0x3a, 0xda, 0xf0, 0x82, 0x7f, 0x68, 0xf4, 0xd3, 0xae, 0xf8, 0x65, 0x37, 0xd4, 0xd2, 0x1e, 0x40,
	0x02, 0x21, 0xb3, 0x68, 0x97, 0xc6, 0x05, 0xda, 0x12, 0x42, 0xed, 0x43, 0xf2, 0x46, 0xa5, 0xcd,
	0x68, 0xe6, 0x5d, 0x34, 0x3b, 0x31, 0x9a, 0x49, 0xdd, 0x4b, 0x2e, 0x04, 0x55, 0x43, 0x72, 0x6a,
	0x77, 0x12, 0x0c, 0x61, 0x07, 0xd8, 0x56, 0x42, 0x8f, 0xbd, 0x6b, 0x0d, 0x9f, 0xdd, 0xec, 0x69,
	0xe1, 0x0b, 0xbb, 0xbf, 0x03, 0xcc, 0xe7, 0x84, 0x54, 0xbf, 0xde, 0x81, 0xc4, 0x20, 0x3f, 0x23,
	0xe4, 0x09, 0xe4, 0x45, 0x4c, 0xd3, 0x1d, 0x60, 0xde, 0x85, 0x86, 0x23, 0x1a, 0x84, 0x57, 0x25,
	0x7d, 0xd1, 0x41, 0xa0, 0xe4, 0xa7, 0xe4, 0xb5, 0x3d, 0x3a, 0x1c, 0x40, 0x1a, 0x79, 0xdf, 0x69,
	0xd0, 0x7b, 0x74, 0xe8, 0xf3, 0x9f, 0xa5, 0xd8, 0xaa, 0xcd, 0x8c, 0x4a, 0x0f, 0xc9, 0x37, 0xfb,
	0x34, 0x7d, 0x1a, 0x0f, 0x79, 0x6e, 0xe7, 0x1b, 0x70, 0xf9, 0x7b, 0x23, 0xb5, 0x0b, 0x76, 0x00,
	0xf5, 0x76, 0xc9, 0xeb, 0x83, 0xd1, 0x94, 0x45, 0xf4, 0x24, 0xd5, 0x52, 0xab, 0x7e, 0xb6, 0xa4,
	0x56, 0x33, 0xa3, 0xd4, 0x53, 0xf2, 0xee, 0xbd, 0x67, 0x0c, 0xf2, 0x34, 0x48, 0xb6, 0x73, 0x9a,
	0xdd, 0x8f, 0x13, 0x28, 0xbc, 0xab, 0x0d, 0xa7, 0xba, 0xdd, 0x17, 0x80, 0x54, 0xbf, 0xb6, 0x18,
	0xc4, 0x38, 0x09, 0xf9, 0x56, 0xdd, 0xdc, 0xa7, 0x29, 0x83, 0x94, 0x79, 0xd7, 0xed, 0x02, 0x88,
	0xc8, 0x58, 0x6b, 0x5d, 0x50, 0x8c, 0x76, 0x40, 0xde, 0xd8, 0x8b, 0xd3, 0xf1, 0x7e, 0x0e, 0xb3,
	0x18, 0x4e, 0xb4, 0xe5, 0x50, 0xb3, 0x58, 0x96, 0x43, 0x93, 0x40, 0xcd, 0x47, 0x84, 0x3c, 0xce,
	0x12, 0x1a, 0x44, 0x7c, 0x64, 0xda, 0x2c, 0x2a, 0x83, 0x65, 0x16, 0x1b, 0x80, 0xda, 0x6d, 0x5b,
	0x09, 0x0d, 0xc7, 0xa5, 0x4d, 0xdb, 0x6d, 0xc2, 0x82, 0x6e, 0x96, 0xdd, 0xa6, 0x21, 0xa8, 0x7a,
	0x44, 0x4e, 0x09, 0xc3, 0x01, 0x64, 0x49, 0x10, 0xea, 0xb5, 0xbe, 0xf4, 0x41, 0x9b, 0xa5, 0xd6,
	0xeb, 0x8c, 0x5a, 0xc4, 0xc2, 0xf2, 0x28, 0x83, 0x54, 0x1b, 0x7e, 0xe9, 0xc1, 0x0d, 0x96, 0xe1,
	0x37, 0x00, 0x4d, 0x6f, 0x30, 0xa2, 0x27, 0x46, 0x3d, 0x6e, 0x70, 0xea, 0x21, 0x80, 0x7a, 0x94,
	0x7c, 0x5b, 0xfc, 0xbc, 0x03, 0x6c, 0x7f, 0x7a, 0x9c, 0xc4, 0xe1, 0x11, 0x1c, 0x3f, 0x3e, 0xd8,
	0xf3, 0xd6, 0x0c, 0x9e, 0x1a, 0x23, 0xa3, 0xdc, 0xe8, 0xc4, 0x6a, 0x01, 0xf9, 0xb0, 0xb6, 0x72,
	0x08, 0xa2, 0x30, 0x9f, 0x4e, 0x8e, 0x0b, 0x63, 0x40, 0x8d, 0x71, 0x06, 0x6c, 0xb3, 0x6a, 0x0f,
	0x95, 0x57, 0x0c, 0x58, 0x3d, 0xde, 0x75, 0xd3, 0xa5, 0x69, 0x20, 0x96, 0x3d, 0x64, 0x41, 0xb5,
	0xe5, 0x89, 0xb7, 0x30, 0xd3, 0xf2, 0xd4, 0x6e, 0x60, 0x97, 0x5c, 0x08, 0xaa, 0xfe, 0x86, 0xbc,
	0x5d, 0x53, 0xdd, 0x0f, 0x86, 0xe0, 0x5d, 0xb1, 0xba, 0x71, 0xb3, 0x54, 0xff, 0x68, 0x11, 0xa6,
	0xee, 0xed, 0xb5, 0x08, 0x03, 0x60, 0xda, 0xbd, 0xbd, 0xee, 0x39, 0xa8, 0x95, 0xdd, 0x2b, 0x0b,
	0x28, 0x7d, 0xd7, 0xa6, 0x49, 0x9c, 0x8e, 0xcd, 0xbb, 0x56, 0x98, 0xdc, 0xbb, 0xb6, 0x42, 0xd4,
	0xed, 0xab, 0x4c, 0x3a, 0xa1, 0x05, 0x78, 0xa6, 0xc5, 0x2e, 0x2c, 0x96, 0x7a, 0xd5, 0x24, 0x54,
	0xa3, 0x20, 0x7e, 0xdf, 0xa6, 0x27, 0xa9, 0x28, 0x30, 0xa6, 0x5d, 0x5e, 0x19, 0x2d, 0x8d, 0x42,
	0x0b, 0x42, 0xed, 0x5f, 0xa0, 0xf6, 0x0e, 0xb0, 0x07, 0x41, 0x3e, 0x2e, 0x8c, 0x97, 0x98, 0xdf,
	0xb2, 0x84, 0xd5, 0x79, 0x89, 0xeb, 0x94, 0x56, 0x19, 0x1e, 0xa7, 0x11, 0x35, 0x56, 0x06, 0x6e,
	0x70, 0x56, 0x06, 0x04, 0x34, 0xbd, 0x03, 0xb0, 0xe8, 0x71, 0x83, 0x53, 0x0f, 0x01, 0xd4, 0xfb,
	0x35, 0xae, 0xb0, 0x01, 0xb0, 0xfb, 0x31, 0x24, 0x51, 0x61, 0x5c, 0xc2, 0x7c, 0xd5, 0x94, 0x66,
	0xe7, 0x12, 0x6e, 0x60, 0x18, 0xe0, 0x4b, 0xac, 0x2c, 0x03, 0xde, 0x58, 0x17, 0x2c, 0x8f, 0x43,
	0x16, 0xd3, 0xb4, 0xf0, 0x6e, 0x58, 0xfc, 0xeb, 0x90, 0x0c, 0x76, 0xb3, 0x1b, 0x8c, 0x21, 0xe7,
	0xe4, 0x4c, 0x15, 0x92, 0x6f, 0xa7, 0xdd, 0x62, 0x33, 0x0f, 0x47, 0xf1, 0x0c, 0x22, 0xcf, 0xb7,
	0xe8, 0x88, 0x5d, 0xa7, 0x38, 0x19, 0xf7, 0x76, 0x67, 0x5e, 0x5b, 0xa8, 0x7b, 0x71, 0xc1, 0x1e,
	0xd0, 0x19, 0x98, 0x16, 0x2a, 0xb7, 0xf9, 0xdc, 0xe8, 0x5a, 0xa8, 0x75, 0x08, 0xb5, 0xa7, 0x38,
	0xac, 0x4a, 0xfb, 0x90, 0x3e, 0x84, 0x13, 0x51, 0x75, 0x6e, 0x3a, 0xfc, 0x25, 0x25, 0xa3, 0xdd,
	0xea, 0x48, 0x63, 0xd8, 0xaf, 0x7a, 0xe4, 0xbc, 0x84, 0xf0, 0xf4, 0xd1, 0x1f, 0xc5, 0x49, 0x94,
	0x43, 0x7a, 0x48, 0x39, 0x5b, 0x78, 0xdf, 0xb3, 0x48, 0x9a, 0x71, 0x99, 0xc9, 0xc7, 0xcb, 0xba,
	0x61, 0x4a, 0x63, 0xe2, 0x49, 0x58, 0x2d, 0xdc, 0xeb, 0x16, 0x35, 0xc3, 0xe2, 0x5d, 0xeb, 0x82,
	0x62, 0xb0, 0x19, 0x39, 0x5d, 0x0f, 0x76, 0x08, 0xcf, 0xd8, 0x80, 0xcd, 0x13, 0xf0, 0x6e, 0x39,
	0x44, 0x38, 0xe5, 0x0b, 0x4c, 0xc6, 0xf4, 0xbb, 0xe2, 0x18, 0x37, 0xae, 0x0d, 0x72, 0x7b, 0x9a,
	0x25, 0x71, 0xc8, 0x6f, 0x5d, 0xd7, 0x2c, 0x2a, 0x92, 0xb0, 0x1c, 0x38, 0xcc, 0x24, 0x86, 0xfa,
	0x6b, 0x8f, 0x9c, 0xab, 0x8f, 0x71, 0x2b, 0x08, 0xc7, 0xc3, 0x9c, 0x4e, 0xd3, 0xa8, 0x4f, 0x13,
	0x9a, 0x7b, 0xeb, 0x8e, 0xd4, 0x35, 0x56, 0x86, 0xdf, 0x58, 0xca, 0x07, 0x13, 0x19, 0x91, 0x77,
	0xeb, 0x79, 0x6c, 0x26, 0xf1, 0x30, 0xb5, 0x0e, 0x99, 0x2b, 0x09, 0x62, 0xe1, 0x90, 0xeb, 0x24,
	0x46, 0x2a, 0xb0, 0x2c, 0x61, 0xa4, 0xed, 0x78, 0x56, 0x4e, 0xea, 0x4d, 0x87, 0xc4, 0x76, 0x3c,
	0xd3, 0xe6, 0xf4, 0x56, 0x47, 0x1a, 0x83, 0xfe, 0xa5, 0x47, 0x56, 0xea, 0x51, 0xb5, 0xea, 0xe4,
	0xba, 0xcc, 0xb6, 0x0a, 0xb5, 0xb1, 0x94, 0x0f, 0xe6, 0x91, 0x62, 0xf3, 0x25, 0x96, 0x16, 0x24,
	0x80, 0xcd, 0x8b, 0x6d, 0x57, 0x94, 0x88, 0xdf, 0x28, 0x22, 0x37, 0x3a, 0xb1, 0xea, 0x60, 0x26,
	0x89, 0xc3, 0x69, 0x9e, 0xee, 0xa6, 0x8c, 0x6a, 0x07, 0x33, 0xa5, 0x50, 0x01, 0x96, 0x83, 0x99,
	0x11, 0xc4, 0x38, 0x43, 0xf2, 0x4e, 0x55, 0xf8, 0xf9, 0x8e, 0xe2, 0xff, 0x98, 0x56, 0x8f, 0xda,
	0x72, 0xe2, 0x5f, 0x8e, 0xd5, 0xd3, 0x22, 0x31, 0xd0, 0x17, 0x38, 0x20, 0x0c, 0x54, 0xee, 0x12,
	0xa7, 0x7f, 0x73, 0x73, 0xac, 0x75, 0x41, 0xed, 0xf5, 0xa7, 0x8c, 0xb7, 0xb0, 0xfe, 0x34, 0x63,
	0xfa, 0x5d, 0x71, 0xf3, 0x0e, 0xe1, 0x08, 0xef, 0x6d, 0x9c, 0x3b, 0x44, 0xe8, 0x70, 0xaa, 0xd3,
	0x0e, 0xa9, 0xd3, 0xe6, 0x0b, 0x5b, 0xee, 0x49, 0xe7, 0x85, 0x6d, 0x6e, 0xc8, 0xb5, 0x2e, 0x28,
	0xc6, 0xca, 0xd4, 0x11, 0x44, 0x5c, 0xd4, 0x11, 0x84, 0x63, 0x88, 0xac, 0x8d, 0x49, 0x79, 0x8d,
	0x4a, 0x68, 0x61, 0x63, 0xa2, 0xc1, 0x5a, 0x67, 0x3c, 0xc8, 0x92, 0x98, 0x19, 0x3b, 0x63, 0x61,
	0x71, 0x76, 0xc6, 0x15, 0xa1, 0x49, 0x3e, 0x80, 0x7c, 0x68, 0x6e, 0xb6, 0x85, 0xc5, 0x29, 0x59,
	0x11, 0x5a, 0x8b, 0xd9, 0xa7, 0xd9, 0xdc, 0xd8, 0x62, 0x72, 0x83, 0xb3, 0xc5, 0x44, 0x40, 0x4b,
	0x71, 0x3f, 0x28, 0x98, 0x39, 0x45, 0x61, 0x71, 0xa6, 0x58, 0x11, 0x28, 0xf9, 0x19, 0x79, 0xbd,
	0x4c, 0x71, 0xca, 0xbc, 0x55, 0x53, 0x02, 0x53, 0x75, 0x11, 0xcf, 0x5b, 0xed, 0xda, 0x29, 0xe8,
	0xde, 0xb3, 0x8c, 0xe6, 0xcc, 0x78, 0x0a, 0x2a, 0x4d, 0xce, 0x53, 0x90, 0x44, 0xb4, 0x03, 0xee,
	0xee, 0x84, 0xff, 0xce, 0x57, 0xb9, 0x78, 0xc4, 0x65, 0x5a, 0xcb, 0x4d, 0xc4, 0xb9, 0x96, 0x5b,
	0x68, 0xbb, 0xf2, 0xdd, 0x8f, 0x13, 0x78, 0x18, 0x4c, 0xc0, 0x5a, 0xf9, 0xc4, 0x93, 0x1b, 0x4e,
	0x2c, 0xac, 0x7c, 0x75, 0xb2, 0xbd, 0x41, 0xc5, 0xe3, 0x4b, 0x11, 0xc9, 0xe6, 0x5f, 0x3e, 0xe0,
	0x6c, 0x84, 0x5a, 0xeb, 0x82, 0x62, 0xac, 0x09, 0x76, 0x40, 0x55, 0xac, 0xa3, 0x38, 0x62, 0x23,
	0xcf, 0xad, 0x20, 0x18, 0xe7, 0x23, 0x89, 0x36, 0xdb, 0x1e, 0xda, 0x93, 0x38, 0x02, 0xea, 0x1c,
	0x9a, 0x20, 0xba, 0x0d, 0xad, 0x81, 0xb6, 0x87, 0x26, 0xcc, 0xee, 0xa1, 0x95, 0x0a, 0xdd, 0x86,
	0xd6, 0x64, 0x31, 0xdc, 0x1f, 0x7b, 0xe4, 0xfd, 0x2a, 0xde, 0x5e, 0x9c, 0x8e, 0x0f, 0x83, 0x7c,
	0x28, 0x9e, 0x60, 0x87, 0xe3, 0xdd, 0xc8, 0xbb, 0x6b, 0x91, 0xe2, 0xa4, 0xdf, 0x40, 0x65, 0xf4,
	0xf5, 0x65, 0x5c, 0xb4, 0xae, 0x7d, 0x8b, 0xd2, 0xf1, 0x24, 0xc8, 0xc7, 0xf7, 0x81, 0x85, 0x23,
	0xe3, 0x05, 0xae, 0x08, 0x5f, 0x20, 0xce, 0x0b, 0xdc, 0x42, 0xf5, 0x96, 0xb6, 0x02, 0xca, 0xc7,
	0x1f, 0x9b, 0x69, 0x54, 0x86, 0x5d, 0x77, 0x69, 0x35, 0x59, 0x57, 0xaf, 0xe5, 0xf0, 0xc1, 0x44,
	0x7e, 0x47, 0xce, 0x0a, 0x92, 0xef, 0x25, 0xc9, 0xe0, 0x63, 0x52, 0xd3, 0xf1, 0x52, 0xec, 0x39,
	0x0d, 0x94, 0x19, 0xdc, 0xe9, 0xee, 0xa0, 0xb5, 0x7a, 0x07, 0x90, 0x04, 0xfc, 0x98, 0x3c, 0x00,
	0xf6, 0x19, 0xcc, 0x8d, 0x2b, 0xad, 0x42, 0xfc, 0x92, 0x71, 0xae, 0xb4, 0x36, 0x8b, 0xf1, 0x00,
	0x0b, 0x51, 0x05, 0x6c, 0x46, 0x91, 0xa9, 0xd3, 0x53, 0x02, 0x9b, 0x51, 0xe4, 0xea, 0xf4, 0x74,
	0x10, 0xc3, 0xfc, 0x96, 0xbc, 0x57, 0x3e, 0x10, 0x0a, 0x58, 0x30, 0x8b, 0xe1, 0xe4, 0x49, 0x0c,
	0x27, 0xf8, 0x70, 0xcf, 0x74, 0xc6, 0xaf, 0x30, 0x5f, 0x71, 0xce, 0x33, 0xbe, 0x99, 0x77, 0xc4,
	0x2e, 0xdb, 0xde, 0xc5, 0xb1, 0xb1, 0x3d, 0xee, 0x1c, 0x5b, 0xf2, 0x8e, 0xd8, 0x8f, 0xb3, 0xa8,
	0xd3, 0xb8, 0x4b, 0xae, 0x7b, 0x6c, 0xc9, 0x63, 0xec, 0x3f, 0x55, 0xa7, 0x97, 0x7a, 0x70, 0x7e,
	0x4a, 0x0b, 0x59, 0x3c, 0x03, 0x63, 0x15, 0x69, 0xe8, 0x49, 0xd4, 0x59, 0x45, 0xac, 0x2e, 0xda,
	0x7e, 0xaa, 0xb8, 0xfa, 0x42, 0x73, 0x0e, 0xa9, 0x06, 0x3a, 0xf7, 0x93, 0xc5, 0x41, 0xaf, 0x2b,
	0x7a, 0x7c, 0x9c, 0x85, 0xf5, 0x2e, 0x8a, 0xda, 0x4c, 0x6c, 0x2c, 0xe5, 0xb3, 0x28, 0x11, 0x5c,
	0x8a, 0x9d, 0x12, 0xd1, 0x96, 0xe3, 0xc6, 0x52, 0x3e, 0x98, 0xc8, 0x3f, 0x7a, 0xe4, 0x92, 0x31,
	0x11, 0xde, 0xe7, 0x6f, 0xce, 0x82, 0x38, 0x09, 0x8e, 0x13, 0xf0, 0x7e, 0xd0, 0x45, 0xbb, 0xe1,
	0x22, 0xd3, 0xfa, 0xe1, 0xcb, 0xb8, 0x62, 0x76, 0xbf, 0xaf, 0xee, 0x7c, 0x2a, 0xbb, 0x90, 0xe6,
	0x11, 0xd6, 0x8a, 0x05, 0xf3, 0xaf, 0x48, 0x99, 0xcb, 0xdd, 0x25, 0x3c, 0xdc, 0x29, 0xe0, 0x82,
	0xe9, 0x90, 0x82, 0xb6, 0x5c, 0xee, 0x2e, 0xe1, 0xe1, 0x4e, 0x01, 0x97, 0x4a, 0x87, 0x14, 0xb4,
	0x85, 0x72, 0x77, 0x09, 0x0f, 0x4c, 0xe1, 0x5f, 0x3d, 0x72, 0xd9, 0x90, 0x42, 0x35, 0x7d, 0x8f,
	0xb2, 0x6a, 0x13, 0xff, 0x68, 0xb1, 0x76, 0xcb, 0x49, 0x26, 0xf6, 0xe3, 0x97, 0x73, 0xc6, 0x1c,
	0xff, 0xdd, 0x23, 0x57, 0x17, 0xe6, 0x88, 0xf3, 0xf6, 0xd3, 0x65, 0x23, 0x69, 0xb3, 0xf8, 0xc9,
	0x4b, 0xfb, 0x2f, 0x93, 0x2c, 0xce, 0xf0, 0xd2, 0xc9, 0x6a, 0xf3, 0xfd, 0xc9, 0x4b, 0xfb, 0x6b,
	0xbd, 0xdf, 0xa3, 0xe3, 0x2f, 0x20, 0x64, 0x87, 0xf3, 0x4c, 0xbc, 0xcc, 0x32, 0xf5, 0x7e, 0x8a,
	0xf0, 0xeb, 0x6f, 0xb4, 0xd6, 0xba, 0xa0, 0x18, 0x2c, 0x27, 0xa7, 0x1f, 0x06, 0xb3, 0x78, 0x28,
	0xeb, 0x42, 0x09, 0xea, 0xef, 0x1c, 0x14, 0xe3, 0xd7, 0x20, 0xcb, 0xd1, 0xde, 0x0a, 0x63, 0xcc,
	0xbf, 0xf7, 0xc8, 0x05, 0xc5, 0xec, 0x00, 0x12, 0xbb, 0xe9, 0x53, 0x7a, 0x14, 0xb3, 0x11, 0xef,
	0x8b, 0x0b, 0xef, 0x63, 0x9b, 0xa4, 0x99, 0x97, 0xa9, 0x7c, 0x7f, 0x69, 0x3f, 0xf5, 0x02, 0xbd,
	0xb4, 0x0f, 0x20, 0xc8, 0xc3, 0x91, 0xf6, 0x02, 0xbd, 0x34, 0xf9, 0xa5, 0xcd, 0xf2, 0x02, 0x5d,
	0x67, 0xd4, 0x13, 0xbd, 0xd2, 0x62, 0xef, 0xf3, 0xd0, 0xd3, 0x74, 0xdb, 0xbd, 0xb6, 0x18, 0x54,
	0xef, 0xa5, 0x9b, 0x71, 0x70, 0xf7, 0xad, 0xb9, 0x14, 0xb4, 0x9d, 0x76, 0xa3, 0x13, 0x6b, 0x0b,
	0x88, 0x3b, 0xc8, 0x19, 0x50, 0xdb, 0x2d, 0x37, 0x3a, 0xb1, 0x18, 0xf0, 0x19, 0x79, 0xaf, 0x19,
	0x50, 0x55, 0xc2, 0x5b, 0x2e, 0x9d, 0x76, 0xed, 0xf3, 0xbb, 0xe2, 0x18, 0xf9, 0x0f, 0x3d, 0xb2,
	0x62, 0x0a, 0x6d, 0xbc, 0x31, 0x19, 0xe5, 0x9c, 0x37, 0x26, 0xb7, 0xc7, 0x82, 0x1c, 0x8c, 0x77,
	0x26, 0xa3, 0xa2, 0xf3, 0xce, 0xe4, 0xf6, 0xc0, 0x1c, 0xfe, 0xdc, 0x23, 0xe7, 0x9a, 0x39, 0x34,
	0x3b, 0x17, 0xa7, 0xa4, 0xb9, 0x63, 0x59, 0x5f, 0xc6, 0x05, 0xd3, 0x38, 0xc6, 0xaf, 0x09, 0x06,
	0xc0, 0xb6, 0x81, 0x05, 0x71, 0x52, 0x78, 0xb6, 0x77, 0xac, 0x68, 0x97, 0xe1, 0xae, 0x2e, 0xe4,
	0xd4, 0xa3, 0xb8, 0xfd, 0x60, 0x88, 0xe7, 0x50, 0xed, 0x51, 0x9c, 0x78, 0x64, 0xaf, 0x75, 0x3b,
	0x17, 0x1d, 0x84, 0x7a, 0x5a, 0x38, 0x90, 0x1f, 0x63, 0x36, 0x9f, 0xb5, 0x0d, 0xda, 0x5f, 0x62,
	0x5e, 0xb0, 0x03, 0xf2, 0x0b, 0xbb, 0x77, 0x54, 0x5d, 0x47, 0xd9, 0x8f, 0x0c, 0x97, 0x53, 0x94,
	0x7d, 0x4d, 0xfd, 0xea, 0x42, 0x4e, 0x7d, 0x57, 0xa1, 0xac, 0x7c, 0x3e, 0xb4, 0x97, 0xfe, 0x35,
	0x57, 0xf1, 0xb4, 0xda, 0xfc, 0xd2, 0xbf, 0x4d, 0xa1, 0xfc, 0x09, 0x39, 0xa3, 0x6c, 0xf5, 0x69,
	0x37, 0x6e, 0x69, 0x21, 0x20, 0x8f, 0xb9, 0x8d, 0x78, 0x7e, 0x57, 0x1c, 0x03, 0x33, 0x72, 0xba,
	0x1d, 0x98, 0x97, 0x92, 0x9b, 0x0b, 0x85, 0xea, 0x95, 0xe4, 0x56, 0x47, 0x5a, 0x1d, 0xc9, 0xda,
	0x51, 0xb1, 0x8a, 0xdc, 0x5e, 0x28, 0xa5, 0x15, 0x91, 0x3b, 0xdd, 0x1d, 0x5c, 0xe1, 0x0f, 0x60,
	0x42, 0x67, 0x5d, 0xc2, 0x97, 0xe0, 0x12, 0xe1, 0xa5, 0x83, 0xfa, 0x0a, 0xa8, 0xba, 0xc7, 0xb2,
	0xbd, 0x60, 0x4e, 0xa7, 0xcc, 0xbb, 0x62, 0xbe, 0x85, 0xa2, 0xd9, 0xf2, 0x09, 0x85, 0x01, 0xab,
	0x75, 0xef, 0xa5, 0xf5, 0x3e, 0x04, 0x6c, 0x9a, 0x43, 0x54, 0x9f, 0x5a, 0x63, 0x8d, 0xd4, 0xc1,
	0xc6, 0xf4, 0xde, 0x5d, 0xc2, 0x03, 0x53, 0xf8, 0x5b, 0x8f, 0x7c, 0x60, 0x4e, 0x01, 0x2f, 0xf4,
	0x46, 0x27, 0x4d, 0xed, 0x62, 0x7f, 0x77, 0x39, 0x27, 0xcc, 0xe5, 0x27, 0xe4, 0x1b, 0xfb, 0x71,
	0x3a, 0xf4, 0xde, 0x6f, 0x16, 0xa7, 0x38, 0x1d, 0x4a, 0xe1, 0x15, 0x93, 0x49, 0x7d, 0xa2, 0xb1,
	0x9f, 0xd3, 0x10, 0x8a, 0xa2, 0x1f, 0xa4, 0x21, 0x24, 0xda, 0x27, 0x1a, 0x68, 0xf3, 0x4b, 0xa3,
	0xe5, 0x13, 0x8d, 0x16, 0xa4, 0x5e, 0x25, 0x7c, 0x1a, 0x17, 0x8c, 0xe6, 0x73, 0xf1, 0x25, 0x60,
	0xb3, 0x7c, 0xa2, 0xa5, 0xf9, 0x2d, 0xe0, 0x25, 0x17, 0xa2, 0x56, 0x18, 0x1a, 0xf0, 0xdb, 0x5e,
	0xfd, 0x23, 0x9d, 0xca, 0xad, 0x32, 0x5b, 0x56, 0x98, 0x01, 0x53, 0xed, 0x5c, 0x95, 0x37, 0x30,
	0x34, 0x6b, 0xed, 0x9c, 0x4c, 0x4d, 0x02, 0x96, 0x76, 0xce, 0x08, 0x62, 0x9c, 0x3e, 0x79, 0x15,
	0xdf, 0xb2, 0x9c, 0xd3, 0xbe, 0x80, 0x6d, 0xbc, 0x5f, 0xf9, 0xc0, 0x6c, 0x44, 0x91, 0x5f, 0x91,
	0xb7, 0xcb, 0x9f, 0x0e, 0x61, 0x92, 0x25, 0x01, 0x03, 0xfd, 0x93, 0x2d, 0xcd, 0x6a, 0xa9, 0xde,
	0x6d, 0x0a, 0xf5, 0x1f, 0x93, 0x53, 0x0f, 0x82, 0x31, 0x54, 0x16, 0x6d, 0x16, 0xeb, 0x26, 0xcb,
	0x2c, 0x6a, 0x88, 0xfc, 0x2a, 0xe9, 0x6c, 0xdd, 0xb0, 0x35, 0x57, 0xc5, 0x45, 0xbb, 0x2d, 0xd8,
	0x30, 0xcb, 0x6d, 0xc1, 0x81, 0x63, 0xe8, 0x9f, 0x93, 0x37, 0xfb, 0x09, 0x4d, 0xd5, 0x90, 0x9a,
	0xf9, 0x36, 0x6c, 0x96, 0x73, 0x80, 0xce, 0x28, 0xe5, 0xcd, 0x2c, 0x4b, 0xe6, 0x16, 0xe5, 0x86,
	0xcd, 0xa2, 0xac, 0x33, 0xaa, 0xaf, 0xd8, 0x86, 0xe3, 0xe9, 0x70, 0x30, 0x4f, 0x43, 0xad, 0xaf,
	0x10, 0xbf, 0xfb, 0xdc, 0x60, 0xe9, 0x2b, 0x1a, 0x80, 0xda, 0x9a, 0xe2, 0xe7, 0xc3, 0x51, 0x0e,
	0xad, 0x2f, 0x94, 0x4b, 0x87, 0xd2, 0x64, 0x99, 0x54, 0x0d, 0xd1, 0xb2, 0x3c, 0xcc, 0x01, 0x8c,
	0x59, 0x72, 0x83, 0x33, 0x4b, 0x04, 0x50, 0xef, 0x0e, 0x39, 0xc5, 0xef, 0xe8, 0x90, 0xde, 0x13,
	0x7f, 0x06, 0xe3, 0xbd, 0x25, 0x3d, 0xee, 0x4d, 0x32, 0x36, 0x5f, 0xa9, 0xfd, 0x3f, 0x07, 0xee,
	0xf4, 0xb6, 0x2e, 0xfe, 0xe7, 0xf9, 0x6a, 0xef, 0xeb, 0xe7, 0xab, 0xbd, 0xff, 0x3d, 0x5f, 0xed,
	0x7d, 0xf5, 0x62, 0xf5, 0x95, 0xaf, 0x5f, 0xac, 0xbe, 0xf2, 0xdf, 0x17, 0xab, 0xaf, 0x7c, 0xfe,
	0x1a, 0xfe, 0x19, 0xce, 0xf1, 0xab, 0xe2, 0x8f, 0x69, 0x36, 0xfe, 0x1f, 0x00, 0x00, 0xff, 0xff,
	0x6e, 0x9c, 0xdf, 0xa9, 0xaa, 0x33, 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 {
	WalletCreate(*pb.RpcWalletCreateRequest) *pb.RpcWalletCreateResponse
	WalletRecover(*pb.RpcWalletRecoverRequest) *pb.RpcWalletRecoverResponse
	WalletConvert(*pb.RpcWalletConvertRequest) *pb.RpcWalletConvertResponse
	AccountRecover(*pb.RpcAccountRecoverRequest) *pb.RpcAccountRecoverResponse
	AccountCreate(*pb.RpcAccountCreateRequest) *pb.RpcAccountCreateResponse
	AccountSelect(*pb.RpcAccountSelectRequest) *pb.RpcAccountSelectResponse
	AccountStop(*pb.RpcAccountStopRequest) *pb.RpcAccountStopResponse
	ImageGetBlob(*pb.RpcIpfsImageGetBlobRequest) *pb.RpcIpfsImageGetBlobResponse
	VersionGet(*pb.RpcVersionGetRequest) *pb.RpcVersionGetResponse
	LogSend(*pb.RpcLogSendRequest) *pb.RpcLogSendResponse
	ConfigGet(*pb.RpcConfigGetRequest) *pb.RpcConfigGetResponse
	Shutdown(*pb.RpcShutdownRequest) *pb.RpcShutdownResponse
	ExternalDropFiles(*pb.RpcExternalDropFilesRequest) *pb.RpcExternalDropFilesResponse
	ExternalDropContent(*pb.RpcExternalDropContentRequest) *pb.RpcExternalDropContentResponse
	LinkPreview(*pb.RpcLinkPreviewRequest) *pb.RpcLinkPreviewResponse
	UploadFile(*pb.RpcUploadFileRequest) *pb.RpcUploadFileResponse
	BlockUpload(*pb.RpcBlockUploadRequest) *pb.RpcBlockUploadResponse
	BlockReplace(*pb.RpcBlockReplaceRequest) *pb.RpcBlockReplaceResponse
	BlockOpen(*pb.RpcBlockOpenRequest) *pb.RpcBlockOpenResponse
	BlockShow(*pb.RpcBlockShowRequest) *pb.RpcBlockShowResponse
	BlockGetPublicWebURL(*pb.RpcBlockGetPublicWebURLRequest) *pb.RpcBlockGetPublicWebURLResponse
	BlockOpenBreadcrumbs(*pb.RpcBlockOpenBreadcrumbsRequest) *pb.RpcBlockOpenBreadcrumbsResponse
	BlockSetBreadcrumbs(*pb.RpcBlockSetBreadcrumbsRequest) *pb.RpcBlockSetBreadcrumbsResponse
	BlockCreate(*pb.RpcBlockCreateRequest) *pb.RpcBlockCreateResponse
	BlockCreatePage(*pb.RpcBlockCreatePageRequest) *pb.RpcBlockCreatePageResponse
	BlockCreateSet(*pb.RpcBlockCreateSetRequest) *pb.RpcBlockCreateSetResponse
	BlockUnlink(*pb.RpcBlockUnlinkRequest) *pb.RpcBlockUnlinkResponse
	BlockClose(*pb.RpcBlockCloseRequest) *pb.RpcBlockCloseResponse
	BlockDownload(*pb.RpcBlockDownloadRequest) *pb.RpcBlockDownloadResponse
	BlockGetMarks(*pb.RpcBlockGetMarksRequest) *pb.RpcBlockGetMarksResponse
	BlockUndo(*pb.RpcBlockUndoRequest) *pb.RpcBlockUndoResponse
	BlockRedo(*pb.RpcBlockRedoRequest) *pb.RpcBlockRedoResponse
	BlockSetFields(*pb.RpcBlockSetFieldsRequest) *pb.RpcBlockSetFieldsResponse
	BlockSetRestrictions(*pb.RpcBlockSetRestrictionsRequest) *pb.RpcBlockSetRestrictionsResponse
	BlockSetPageIsArchived(*pb.RpcBlockSetPageIsArchivedRequest) *pb.RpcBlockSetPageIsArchivedResponse
	BlockListMove(*pb.RpcBlockListMoveRequest) *pb.RpcBlockListMoveResponse
	BlockListMoveToNewPage(*pb.RpcBlockListMoveToNewPageRequest) *pb.RpcBlockListMoveToNewPageResponse
	BlockListConvertChildrenToPages(*pb.RpcBlockListConvertChildrenToPagesRequest) *pb.RpcBlockListConvertChildrenToPagesResponse
	BlockListSetFields(*pb.RpcBlockListSetFieldsRequest) *pb.RpcBlockListSetFieldsResponse
	BlockListSetTextStyle(*pb.RpcBlockListSetTextStyleRequest) *pb.RpcBlockListSetTextStyleResponse
	BlockListDuplicate(*pb.RpcBlockListDuplicateRequest) *pb.RpcBlockListDuplicateResponse
	BlockListSetBackgroundColor(*pb.RpcBlockListSetBackgroundColorRequest) *pb.RpcBlockListSetBackgroundColorResponse
	BlockListSetAlign(*pb.RpcBlockListSetAlignRequest) *pb.RpcBlockListSetAlignResponse
	BlockListSetDivStyle(*pb.RpcBlockListSetDivStyleRequest) *pb.RpcBlockListSetDivStyleResponse
	BlockListSetPageIsArchived(*pb.RpcBlockListSetPageIsArchivedRequest) *pb.RpcBlockListSetPageIsArchivedResponse
	BlockListDeletePage(*pb.RpcBlockListDeletePageRequest) *pb.RpcBlockListDeletePageResponse
	BlockListTurnInto(*pb.RpcBlockListTurnIntoRequest) *pb.RpcBlockListTurnIntoResponse
	BlockSetTextText(*pb.RpcBlockSetTextTextRequest) *pb.RpcBlockSetTextTextResponse
	BlockSetTextColor(*pb.RpcBlockSetTextColorRequest) *pb.RpcBlockSetTextColorResponse
	BlockListSetTextColor(*pb.RpcBlockListSetTextColorRequest) *pb.RpcBlockListSetTextColorResponse
	BlockListSetTextMark(*pb.RpcBlockListSetTextMarkRequest) *pb.RpcBlockListSetTextMarkResponse
	BlockSetTextStyle(*pb.RpcBlockSetTextStyleRequest) *pb.RpcBlockSetTextStyleResponse
	BlockSetTextChecked(*pb.RpcBlockSetTextCheckedRequest) *pb.RpcBlockSetTextCheckedResponse
	BlockSplit(*pb.RpcBlockSplitRequest) *pb.RpcBlockSplitResponse
	BlockMerge(*pb.RpcBlockMergeRequest) *pb.RpcBlockMergeResponse
	BlockCopy(*pb.RpcBlockCopyRequest) *pb.RpcBlockCopyResponse
	BlockPaste(*pb.RpcBlockPasteRequest) *pb.RpcBlockPasteResponse
	BlockCut(*pb.RpcBlockCutRequest) *pb.RpcBlockCutResponse
	BlockExport(*pb.RpcBlockExportRequest) *pb.RpcBlockExportResponse
	BlockImportMarkdown(*pb.RpcBlockImportMarkdownRequest) *pb.RpcBlockImportMarkdownResponse
	BlockSetFileName(*pb.RpcBlockSetFileNameRequest) *pb.RpcBlockSetFileNameResponse
	BlockSetImageName(*pb.RpcBlockSetImageNameRequest) *pb.RpcBlockSetImageNameResponse
	BlockSetImageWidth(*pb.RpcBlockSetImageWidthRequest) *pb.RpcBlockSetImageWidthResponse
	BlockSetVideoName(*pb.RpcBlockSetVideoNameRequest) *pb.RpcBlockSetVideoNameResponse
	BlockSetVideoWidth(*pb.RpcBlockSetVideoWidthRequest) *pb.RpcBlockSetVideoWidthResponse
	BlockSetLinkTargetBlockId(*pb.RpcBlockSetLinkTargetBlockIdRequest) *pb.RpcBlockSetLinkTargetBlockIdResponse
	BlockBookmarkFetch(*pb.RpcBlockBookmarkFetchRequest) *pb.RpcBlockBookmarkFetchResponse
	BlockBookmarkCreateAndFetch(*pb.RpcBlockBookmarkCreateAndFetchRequest) *pb.RpcBlockBookmarkCreateAndFetchResponse
	BlockFileCreateAndUpload(*pb.RpcBlockFileCreateAndUploadRequest) *pb.RpcBlockFileCreateAndUploadResponse
	BlockRelationSetKey(*pb.RpcBlockRelationSetKeyRequest) *pb.RpcBlockRelationSetKeyResponse
	BlockRelationAdd(*pb.RpcBlockRelationAddRequest) *pb.RpcBlockRelationAddResponse
	// ## Dataview
	// # View
	BlockDataviewViewCreate(*pb.RpcBlockDataviewViewCreateRequest) *pb.RpcBlockDataviewViewCreateResponse
	BlockDataviewViewDelete(*pb.RpcBlockDataviewViewDeleteRequest) *pb.RpcBlockDataviewViewDeleteResponse
	BlockDataviewViewUpdate(*pb.RpcBlockDataviewViewUpdateRequest) *pb.RpcBlockDataviewViewUpdateResponse
	BlockDataviewViewSetActive(*pb.RpcBlockDataviewViewSetActiveRequest) *pb.RpcBlockDataviewViewSetActiveResponse
	// # Relation
	BlockDataviewRelationAdd(*pb.RpcBlockDataviewRelationAddRequest) *pb.RpcBlockDataviewRelationAddResponse
	BlockDataviewRelationUpdate(*pb.RpcBlockDataviewRelationUpdateRequest) *pb.RpcBlockDataviewRelationUpdateResponse
	BlockDataviewRelationDelete(*pb.RpcBlockDataviewRelationDeleteRequest) *pb.RpcBlockDataviewRelationDeleteResponse
	BlockDataviewRelationListAvailable(*pb.RpcBlockDataviewRelationListAvailableRequest) *pb.RpcBlockDataviewRelationListAvailableResponse
	// # Record
	BlockDataviewRecordCreate(*pb.RpcBlockDataviewRecordCreateRequest) *pb.RpcBlockDataviewRecordCreateResponse
	BlockDataviewRecordUpdate(*pb.RpcBlockDataviewRecordUpdateRequest) *pb.RpcBlockDataviewRecordUpdateResponse
	BlockDataviewRecordDelete(*pb.RpcBlockDataviewRecordDeleteRequest) *pb.RpcBlockDataviewRecordDeleteResponse
	BlockDataviewRecordRelationOptionAdd(*pb.RpcBlockDataviewRecordRelationOptionAddRequest) *pb.RpcBlockDataviewRecordRelationOptionAddResponse
	BlockDataviewRecordRelationOptionUpdate(*pb.RpcBlockDataviewRecordRelationOptionUpdateRequest) *pb.RpcBlockDataviewRecordRelationOptionUpdateResponse
	BlockDataviewRecordRelationOptionDelete(*pb.RpcBlockDataviewRecordRelationOptionDeleteRequest) *pb.RpcBlockDataviewRecordRelationOptionDeleteResponse
	// ## Object's relations
	// set an existing object type to the object so it will appear in sets and suggests relations from this type
	// TODO: rename BlockObjectTypeSet -> ObjectObjectTypeSet
	BlockObjectTypeSet(*pb.RpcBlockObjectTypeSetRequest) *pb.RpcBlockObjectTypeSetResponse
	NavigationListObjects(*pb.RpcNavigationListObjectsRequest) *pb.RpcNavigationListObjectsResponse
	NavigationGetObjectInfoWithLinks(*pb.RpcNavigationGetObjectInfoWithLinksRequest) *pb.RpcNavigationGetObjectInfoWithLinksResponse
	ObjectSearch(*pb.RpcObjectSearchRequest) *pb.RpcObjectSearchResponse
	ObjectRelationAdd(*pb.RpcObjectRelationAddRequest) *pb.RpcObjectRelationAddResponse
	ObjectRelationUpdate(*pb.RpcObjectRelationUpdateRequest) *pb.RpcObjectRelationUpdateResponse
	ObjectRelationDelete(*pb.RpcObjectRelationDeleteRequest) *pb.RpcObjectRelationDeleteResponse
	ObjectRelationOptionAdd(*pb.RpcObjectRelationOptionAddRequest) *pb.RpcObjectRelationOptionAddResponse
	ObjectRelationOptionUpdate(*pb.RpcObjectRelationOptionUpdateRequest) *pb.RpcObjectRelationOptionUpdateResponse
	ObjectRelationOptionDelete(*pb.RpcObjectRelationOptionDeleteRequest) *pb.RpcObjectRelationOptionDeleteResponse
	ObjectRelationListAvailable(*pb.RpcObjectRelationListAvailableRequest) *pb.RpcObjectRelationListAvailableResponse
	// TODO: rename BlockSetDetails -> ObjectSetDetails
	BlockSetDetails(*pb.RpcBlockSetDetailsRequest) *pb.RpcBlockSetDetailsResponse
	// PageCreate just creates the new page, without adding the link to it from some other page
	// TODO: rename PageCreate -> ObjectCreate
	PageCreate(*pb.RpcPageCreateRequest) *pb.RpcPageCreateResponse
	// SetCreate just creates the new set, without adding the link to it from some other page
	SetCreate(*pb.RpcSetCreateRequest) *pb.RpcSetCreateResponse
	// ## ObjectType
	ObjectTypeCreate(*pb.RpcObjectTypeCreateRequest) *pb.RpcObjectTypeCreateResponse
	// ObjectTypeList lists all object types both bundled and created by user
	ObjectTypeList(*pb.RpcObjectTypeListRequest) *pb.RpcObjectTypeListResponse
	ObjectTypeRelationList(*pb.RpcObjectTypeRelationListRequest) *pb.RpcObjectTypeRelationListResponse
	ObjectTypeRelationAdd(*pb.RpcObjectTypeRelationAddRequest) *pb.RpcObjectTypeRelationAddResponse
	ObjectTypeRelationUpdate(*pb.RpcObjectTypeRelationUpdateRequest) *pb.RpcObjectTypeRelationUpdateResponse
	ObjectTypeRelationRemove(*pb.RpcObjectTypeRelationRemoveRequest) *pb.RpcObjectTypeRelationRemoveResponse
	ObjectSetLayout(*pb.RpcObjectSetLayoutRequest) *pb.RpcObjectSetLayoutResponse
	ObjectFeaturedRelationAdd(*pb.RpcObjectFeaturedRelationAddRequest) *pb.RpcObjectFeaturedRelationAddResponse
	ObjectFeaturedRelationRemove(*pb.RpcObjectFeaturedRelationRemoveRequest) *pb.RpcObjectFeaturedRelationRemoveResponse
	Ping(*pb.RpcPingRequest) *pb.RpcPingResponse
	ProcessCancel(*pb.RpcProcessCancelRequest) *pb.RpcProcessCancelResponse
	HistoryShow(*pb.RpcHistoryShowRequest) *pb.RpcHistoryShowResponse
	HistoryVersions(*pb.RpcHistoryVersionsRequest) *pb.RpcHistoryVersionsResponse
	HistorySetVersion(*pb.RpcHistorySetVersionRequest) *pb.RpcHistorySetVersionResponse
	Export(*pb.RpcExportRequest) *pb.RpcExportResponse
	ExportTemplates(*pb.RpcExportTemplatesRequest) *pb.RpcExportTemplatesResponse
	MakeTemplate(*pb.RpcMakeTemplateRequest) *pb.RpcMakeTemplateResponse
	MakeTemplateByObjectType(*pb.RpcMakeTemplateByObjectTypeRequest) *pb.RpcMakeTemplateByObjectTypeResponse
	CloneTemplate(*pb.RpcCloneTemplateRequest) *pb.RpcCloneTemplateResponse
	ApplyTemplate(*pb.RpcApplyTemplateRequest) *pb.RpcApplyTemplateResponse
	DebugSync(*pb.RpcDebugSyncRequest) *pb.RpcDebugSyncResponse
	DebugThread(*pb.RpcDebugThreadRequest) *pb.RpcDebugThreadResponse
	DebugTree(*pb.RpcDebugTreeRequest) *pb.RpcDebugTreeResponse
	// used only for lib-server via grpc
	// Streams not supported ### ListenEvents(*pb.Empty)
}

func registerClientCommandsHandler(srv ClientCommandsHandler) {
	clientCommandsHandler = srv
}

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(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(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(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(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(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(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcIpfsImageGetBlobRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcIpfsImageGetBlobResponse{Error: &pb.RpcIpfsImageGetBlobResponseError{Code: pb.RpcIpfsImageGetBlobResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ImageGetBlob(in).Marshal()
	return resp
}

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

	in := new(pb.RpcVersionGetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcVersionGetResponse{Error: &pb.RpcVersionGetResponseError{Code: pb.RpcVersionGetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.VersionGet(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcConfigGetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcConfigGetResponse{Error: &pb.RpcConfigGetResponseError{Code: pb.RpcConfigGetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ConfigGet(in).Marshal()
	return resp
}

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

	in := new(pb.RpcShutdownRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcShutdownResponse{Error: &pb.RpcShutdownResponseError{Code: pb.RpcShutdownResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.Shutdown(in).Marshal()
	return resp
}

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

	in := new(pb.RpcExternalDropFilesRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcExternalDropFilesResponse{Error: &pb.RpcExternalDropFilesResponseError{Code: pb.RpcExternalDropFilesResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ExternalDropFiles(in).Marshal()
	return resp
}

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

	in := new(pb.RpcExternalDropContentRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcExternalDropContentResponse{Error: &pb.RpcExternalDropContentResponseError{Code: pb.RpcExternalDropContentResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ExternalDropContent(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcUploadFileRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcUploadFileResponse{Error: &pb.RpcUploadFileResponseError{Code: pb.RpcUploadFileResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.UploadFile(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(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockOpenRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockOpenResponse{Error: &pb.RpcBlockOpenResponseError{Code: pb.RpcBlockOpenResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockOpen(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockShowRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockShowResponse{Error: &pb.RpcBlockShowResponseError{Code: pb.RpcBlockShowResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockShow(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockGetPublicWebURLRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockGetPublicWebURLResponse{Error: &pb.RpcBlockGetPublicWebURLResponseError{Code: pb.RpcBlockGetPublicWebURLResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockGetPublicWebURL(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockOpenBreadcrumbsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockOpenBreadcrumbsResponse{Error: &pb.RpcBlockOpenBreadcrumbsResponseError{Code: pb.RpcBlockOpenBreadcrumbsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockOpenBreadcrumbs(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetBreadcrumbsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetBreadcrumbsResponse{Error: &pb.RpcBlockSetBreadcrumbsResponseError{Code: pb.RpcBlockSetBreadcrumbsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetBreadcrumbs(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockCreatePageRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockCreatePageResponse{Error: &pb.RpcBlockCreatePageResponseError{Code: pb.RpcBlockCreatePageResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockCreatePage(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockCreateSetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockCreateSetResponse{Error: &pb.RpcBlockCreateSetResponseError{Code: pb.RpcBlockCreateSetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockCreateSet(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockUnlinkRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockUnlinkResponse{Error: &pb.RpcBlockUnlinkResponseError{Code: pb.RpcBlockUnlinkResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockUnlink(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockCloseRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockCloseResponse{Error: &pb.RpcBlockCloseResponseError{Code: pb.RpcBlockCloseResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockClose(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockDownloadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDownloadResponse{Error: &pb.RpcBlockDownloadResponseError{Code: pb.RpcBlockDownloadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDownload(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockGetMarksRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockGetMarksResponse{Error: &pb.RpcBlockGetMarksResponseError{Code: pb.RpcBlockGetMarksResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockGetMarks(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockUndoRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockUndoResponse{Error: &pb.RpcBlockUndoResponseError{Code: pb.RpcBlockUndoResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockUndo(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockRedoRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockRedoResponse{Error: &pb.RpcBlockRedoResponseError{Code: pb.RpcBlockRedoResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockRedo(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetRestrictionsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetRestrictionsResponse{Error: &pb.RpcBlockSetRestrictionsResponseError{Code: pb.RpcBlockSetRestrictionsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetRestrictions(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetPageIsArchivedRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetPageIsArchivedResponse{Error: &pb.RpcBlockSetPageIsArchivedResponseError{Code: pb.RpcBlockSetPageIsArchivedResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetPageIsArchived(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockListMoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListMoveResponse{Error: &pb.RpcBlockListMoveResponseError{Code: pb.RpcBlockListMoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListMove(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockListMoveToNewPageRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListMoveToNewPageResponse{Error: &pb.RpcBlockListMoveToNewPageResponseError{Code: pb.RpcBlockListMoveToNewPageResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListMoveToNewPage(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockListConvertChildrenToPagesRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListConvertChildrenToPagesResponse{Error: &pb.RpcBlockListConvertChildrenToPagesResponseError{Code: pb.RpcBlockListConvertChildrenToPagesResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListConvertChildrenToPages(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockListSetTextStyleRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListSetTextStyleResponse{Error: &pb.RpcBlockListSetTextStyleResponseError{Code: pb.RpcBlockListSetTextStyleResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListSetTextStyle(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(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(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockListSetDivStyleRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListSetDivStyleResponse{Error: &pb.RpcBlockListSetDivStyleResponseError{Code: pb.RpcBlockListSetDivStyleResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListSetDivStyle(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockListSetPageIsArchivedRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListSetPageIsArchivedResponse{Error: &pb.RpcBlockListSetPageIsArchivedResponseError{Code: pb.RpcBlockListSetPageIsArchivedResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListSetPageIsArchived(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockListDeletePageRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListDeletePageResponse{Error: &pb.RpcBlockListDeletePageResponseError{Code: pb.RpcBlockListDeletePageResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListDeletePage(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetTextTextRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetTextTextResponse{Error: &pb.RpcBlockSetTextTextResponseError{Code: pb.RpcBlockSetTextTextResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetTextText(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetTextColorRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetTextColorResponse{Error: &pb.RpcBlockSetTextColorResponseError{Code: pb.RpcBlockSetTextColorResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetTextColor(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockListSetTextColorRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListSetTextColorResponse{Error: &pb.RpcBlockListSetTextColorResponseError{Code: pb.RpcBlockListSetTextColorResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListSetTextColor(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockListSetTextMarkRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockListSetTextMarkResponse{Error: &pb.RpcBlockListSetTextMarkResponseError{Code: pb.RpcBlockListSetTextMarkResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockListSetTextMark(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetTextStyleRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetTextStyleResponse{Error: &pb.RpcBlockSetTextStyleResponseError{Code: pb.RpcBlockSetTextStyleResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetTextStyle(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetTextCheckedRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetTextCheckedResponse{Error: &pb.RpcBlockSetTextCheckedResponseError{Code: pb.RpcBlockSetTextCheckedResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetTextChecked(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(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(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(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(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(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockImportMarkdownRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockImportMarkdownResponse{Error: &pb.RpcBlockImportMarkdownResponseError{Code: pb.RpcBlockImportMarkdownResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockImportMarkdown(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetFileNameRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetFileNameResponse{Error: &pb.RpcBlockSetFileNameResponseError{Code: pb.RpcBlockSetFileNameResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetFileName(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetImageNameRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetImageNameResponse{Error: &pb.RpcBlockSetImageNameResponseError{Code: pb.RpcBlockSetImageNameResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetImageName(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetImageWidthRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetImageWidthResponse{Error: &pb.RpcBlockSetImageWidthResponseError{Code: pb.RpcBlockSetImageWidthResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetImageWidth(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetVideoNameRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetVideoNameResponse{Error: &pb.RpcBlockSetVideoNameResponseError{Code: pb.RpcBlockSetVideoNameResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetVideoName(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetVideoWidthRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetVideoWidthResponse{Error: &pb.RpcBlockSetVideoWidthResponseError{Code: pb.RpcBlockSetVideoWidthResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetVideoWidth(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetLinkTargetBlockIdRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetLinkTargetBlockIdResponse{Error: &pb.RpcBlockSetLinkTargetBlockIdResponseError{Code: pb.RpcBlockSetLinkTargetBlockIdResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetLinkTargetBlockId(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(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(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(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(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(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(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(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(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(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockDataviewRelationUpdateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRelationUpdateResponse{Error: &pb.RpcBlockDataviewRelationUpdateResponseError{Code: pb.RpcBlockDataviewRelationUpdateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRelationUpdate(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockDataviewRelationListAvailableRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRelationListAvailableResponse{Error: &pb.RpcBlockDataviewRelationListAvailableResponseError{Code: pb.RpcBlockDataviewRelationListAvailableResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRelationListAvailable(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockDataviewRecordCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRecordCreateResponse{Error: &pb.RpcBlockDataviewRecordCreateResponseError{Code: pb.RpcBlockDataviewRecordCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRecordCreate(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockDataviewRecordUpdateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRecordUpdateResponse{Error: &pb.RpcBlockDataviewRecordUpdateResponseError{Code: pb.RpcBlockDataviewRecordUpdateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRecordUpdate(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockDataviewRecordDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRecordDeleteResponse{Error: &pb.RpcBlockDataviewRecordDeleteResponseError{Code: pb.RpcBlockDataviewRecordDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRecordDelete(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockDataviewRecordRelationOptionAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRecordRelationOptionAddResponse{Error: &pb.RpcBlockDataviewRecordRelationOptionAddResponseError{Code: pb.RpcBlockDataviewRecordRelationOptionAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRecordRelationOptionAdd(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockDataviewRecordRelationOptionUpdateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRecordRelationOptionUpdateResponse{Error: &pb.RpcBlockDataviewRecordRelationOptionUpdateResponseError{Code: pb.RpcBlockDataviewRecordRelationOptionUpdateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRecordRelationOptionUpdate(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockDataviewRecordRelationOptionDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockDataviewRecordRelationOptionDeleteResponse{Error: &pb.RpcBlockDataviewRecordRelationOptionDeleteResponseError{Code: pb.RpcBlockDataviewRecordRelationOptionDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockDataviewRecordRelationOptionDelete(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockObjectTypeSetRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockObjectTypeSetResponse{Error: &pb.RpcBlockObjectTypeSetResponseError{Code: pb.RpcBlockObjectTypeSetResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockObjectTypeSet(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(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(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(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcObjectRelationUpdateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRelationUpdateResponse{Error: &pb.RpcObjectRelationUpdateResponseError{Code: pb.RpcObjectRelationUpdateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRelationUpdate(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcObjectRelationOptionAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRelationOptionAddResponse{Error: &pb.RpcObjectRelationOptionAddResponseError{Code: pb.RpcObjectRelationOptionAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRelationOptionAdd(in).Marshal()
	return resp
}

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

	in := new(pb.RpcObjectRelationOptionUpdateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRelationOptionUpdateResponse{Error: &pb.RpcObjectRelationOptionUpdateResponseError{Code: pb.RpcObjectRelationOptionUpdateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRelationOptionUpdate(in).Marshal()
	return resp
}

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

	in := new(pb.RpcObjectRelationOptionDeleteRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectRelationOptionDeleteResponse{Error: &pb.RpcObjectRelationOptionDeleteResponseError{Code: pb.RpcObjectRelationOptionDeleteResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectRelationOptionDelete(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcBlockSetDetailsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcBlockSetDetailsResponse{Error: &pb.RpcBlockSetDetailsResponseError{Code: pb.RpcBlockSetDetailsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.BlockSetDetails(in).Marshal()
	return resp
}

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

	in := new(pb.RpcPageCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcPageCreateResponse{Error: &pb.RpcPageCreateResponseError{Code: pb.RpcPageCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.PageCreate(in).Marshal()
	return resp
}

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

	in := new(pb.RpcSetCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcSetCreateResponse{Error: &pb.RpcSetCreateResponseError{Code: pb.RpcSetCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.SetCreate(in).Marshal()
	return resp
}

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

	in := new(pb.RpcObjectTypeCreateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeCreateResponse{Error: &pb.RpcObjectTypeCreateResponseError{Code: pb.RpcObjectTypeCreateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeCreate(in).Marshal()
	return resp
}

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

	in := new(pb.RpcObjectTypeListRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeListResponse{Error: &pb.RpcObjectTypeListResponseError{Code: pb.RpcObjectTypeListResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeList(in).Marshal()
	return resp
}

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

	in := new(pb.RpcObjectTypeRelationListRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeRelationListResponse{Error: &pb.RpcObjectTypeRelationListResponseError{Code: pb.RpcObjectTypeRelationListResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeRelationList(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcObjectTypeRelationUpdateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectTypeRelationUpdateResponse{Error: &pb.RpcObjectTypeRelationUpdateResponseError{Code: pb.RpcObjectTypeRelationUpdateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectTypeRelationUpdate(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(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcObjectFeaturedRelationAddRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectFeaturedRelationAddResponse{Error: &pb.RpcObjectFeaturedRelationAddResponseError{Code: pb.RpcObjectFeaturedRelationAddResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectFeaturedRelationAdd(in).Marshal()
	return resp
}

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

	in := new(pb.RpcObjectFeaturedRelationRemoveRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcObjectFeaturedRelationRemoveResponse{Error: &pb.RpcObjectFeaturedRelationRemoveResponseError{Code: pb.RpcObjectFeaturedRelationRemoveResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ObjectFeaturedRelationRemove(in).Marshal()
	return resp
}

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

	in := new(pb.RpcPingRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcPingResponse{Error: &pb.RpcPingResponseError{Code: pb.RpcPingResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.Ping(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcHistoryShowRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcHistoryShowResponse{Error: &pb.RpcHistoryShowResponseError{Code: pb.RpcHistoryShowResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.HistoryShow(in).Marshal()
	return resp
}

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

	in := new(pb.RpcHistoryVersionsRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcHistoryVersionsResponse{Error: &pb.RpcHistoryVersionsResponseError{Code: pb.RpcHistoryVersionsResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.HistoryVersions(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(in).Marshal()
	return resp
}

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

	in := new(pb.RpcExportRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcExportResponse{Error: &pb.RpcExportResponseError{Code: pb.RpcExportResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.Export(in).Marshal()
	return resp
}

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

	in := new(pb.RpcExportTemplatesRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcExportTemplatesResponse{Error: &pb.RpcExportTemplatesResponseError{Code: pb.RpcExportTemplatesResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ExportTemplates(in).Marshal()
	return resp
}

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

	in := new(pb.RpcMakeTemplateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMakeTemplateResponse{Error: &pb.RpcMakeTemplateResponseError{Code: pb.RpcMakeTemplateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MakeTemplate(in).Marshal()
	return resp
}

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

	in := new(pb.RpcMakeTemplateByObjectTypeRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcMakeTemplateByObjectTypeResponse{Error: &pb.RpcMakeTemplateByObjectTypeResponseError{Code: pb.RpcMakeTemplateByObjectTypeResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.MakeTemplateByObjectType(in).Marshal()
	return resp
}

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

	in := new(pb.RpcCloneTemplateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcCloneTemplateResponse{Error: &pb.RpcCloneTemplateResponseError{Code: pb.RpcCloneTemplateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.CloneTemplate(in).Marshal()
	return resp
}

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

	in := new(pb.RpcApplyTemplateRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcApplyTemplateResponse{Error: &pb.RpcApplyTemplateResponseError{Code: pb.RpcApplyTemplateResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.ApplyTemplate(in).Marshal()
	return resp
}

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

	in := new(pb.RpcDebugSyncRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugSyncResponse{Error: &pb.RpcDebugSyncResponseError{Code: pb.RpcDebugSyncResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugSync(in).Marshal()
	return resp
}

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

	in := new(pb.RpcDebugThreadRequest)
	if err := in.Unmarshal(b); err != nil {
		resp, _ = (&pb.RpcDebugThreadResponse{Error: &pb.RpcDebugThreadResponseError{Code: pb.RpcDebugThreadResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
		return resp
	}

	resp, _ = clientCommandsHandler.DebugThread(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(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 "WalletCreate":
			cd = WalletCreate(data)
		case "WalletRecover":
			cd = WalletRecover(data)
		case "WalletConvert":
			cd = WalletConvert(data)
		case "AccountRecover":
			cd = AccountRecover(data)
		case "AccountCreate":
			cd = AccountCreate(data)
		case "AccountSelect":
			cd = AccountSelect(data)
		case "AccountStop":
			cd = AccountStop(data)
		case "ImageGetBlob":
			cd = ImageGetBlob(data)
		case "VersionGet":
			cd = VersionGet(data)
		case "LogSend":
			cd = LogSend(data)
		case "ConfigGet":
			cd = ConfigGet(data)
		case "Shutdown":
			cd = Shutdown(data)
		case "ExternalDropFiles":
			cd = ExternalDropFiles(data)
		case "ExternalDropContent":
			cd = ExternalDropContent(data)
		case "LinkPreview":
			cd = LinkPreview(data)
		case "UploadFile":
			cd = UploadFile(data)
		case "BlockUpload":
			cd = BlockUpload(data)
		case "BlockReplace":
			cd = BlockReplace(data)
		case "BlockOpen":
			cd = BlockOpen(data)
		case "BlockShow":
			cd = BlockShow(data)
		case "BlockGetPublicWebURL":
			cd = BlockGetPublicWebURL(data)
		case "BlockOpenBreadcrumbs":
			cd = BlockOpenBreadcrumbs(data)
		case "BlockSetBreadcrumbs":
			cd = BlockSetBreadcrumbs(data)
		case "BlockCreate":
			cd = BlockCreate(data)
		case "BlockCreatePage":
			cd = BlockCreatePage(data)
		case "BlockCreateSet":
			cd = BlockCreateSet(data)
		case "BlockUnlink":
			cd = BlockUnlink(data)
		case "BlockClose":
			cd = BlockClose(data)
		case "BlockDownload":
			cd = BlockDownload(data)
		case "BlockGetMarks":
			cd = BlockGetMarks(data)
		case "BlockUndo":
			cd = BlockUndo(data)
		case "BlockRedo":
			cd = BlockRedo(data)
		case "BlockSetFields":
			cd = BlockSetFields(data)
		case "BlockSetRestrictions":
			cd = BlockSetRestrictions(data)
		case "BlockSetPageIsArchived":
			cd = BlockSetPageIsArchived(data)
		case "BlockListMove":
			cd = BlockListMove(data)
		case "BlockListMoveToNewPage":
			cd = BlockListMoveToNewPage(data)
		case "BlockListConvertChildrenToPages":
			cd = BlockListConvertChildrenToPages(data)
		case "BlockListSetFields":
			cd = BlockListSetFields(data)
		case "BlockListSetTextStyle":
			cd = BlockListSetTextStyle(data)
		case "BlockListDuplicate":
			cd = BlockListDuplicate(data)
		case "BlockListSetBackgroundColor":
			cd = BlockListSetBackgroundColor(data)
		case "BlockListSetAlign":
			cd = BlockListSetAlign(data)
		case "BlockListSetDivStyle":
			cd = BlockListSetDivStyle(data)
		case "BlockListSetPageIsArchived":
			cd = BlockListSetPageIsArchived(data)
		case "BlockListDeletePage":
			cd = BlockListDeletePage(data)
		case "BlockListTurnInto":
			cd = BlockListTurnInto(data)
		case "BlockSetTextText":
			cd = BlockSetTextText(data)
		case "BlockSetTextColor":
			cd = BlockSetTextColor(data)
		case "BlockListSetTextColor":
			cd = BlockListSetTextColor(data)
		case "BlockListSetTextMark":
			cd = BlockListSetTextMark(data)
		case "BlockSetTextStyle":
			cd = BlockSetTextStyle(data)
		case "BlockSetTextChecked":
			cd = BlockSetTextChecked(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 "BlockExport":
			cd = BlockExport(data)
		case "BlockImportMarkdown":
			cd = BlockImportMarkdown(data)
		case "BlockSetFileName":
			cd = BlockSetFileName(data)
		case "BlockSetImageName":
			cd = BlockSetImageName(data)
		case "BlockSetImageWidth":
			cd = BlockSetImageWidth(data)
		case "BlockSetVideoName":
			cd = BlockSetVideoName(data)
		case "BlockSetVideoWidth":
			cd = BlockSetVideoWidth(data)
		case "BlockSetLinkTargetBlockId":
			cd = BlockSetLinkTargetBlockId(data)
		case "BlockBookmarkFetch":
			cd = BlockBookmarkFetch(data)
		case "BlockBookmarkCreateAndFetch":
			cd = BlockBookmarkCreateAndFetch(data)
		case "BlockFileCreateAndUpload":
			cd = BlockFileCreateAndUpload(data)
		case "BlockRelationSetKey":
			cd = BlockRelationSetKey(data)
		case "BlockRelationAdd":
			cd = BlockRelationAdd(data)
		case "BlockDataviewViewCreate":
			cd = BlockDataviewViewCreate(data)
		case "BlockDataviewViewDelete":
			cd = BlockDataviewViewDelete(data)
		case "BlockDataviewViewUpdate":
			cd = BlockDataviewViewUpdate(data)
		case "BlockDataviewViewSetActive":
			cd = BlockDataviewViewSetActive(data)
		case "BlockDataviewRelationAdd":
			cd = BlockDataviewRelationAdd(data)
		case "BlockDataviewRelationUpdate":
			cd = BlockDataviewRelationUpdate(data)
		case "BlockDataviewRelationDelete":
			cd = BlockDataviewRelationDelete(data)
		case "BlockDataviewRelationListAvailable":
			cd = BlockDataviewRelationListAvailable(data)
		case "BlockDataviewRecordCreate":
			cd = BlockDataviewRecordCreate(data)
		case "BlockDataviewRecordUpdate":
			cd = BlockDataviewRecordUpdate(data)
		case "BlockDataviewRecordDelete":
			cd = BlockDataviewRecordDelete(data)
		case "BlockDataviewRecordRelationOptionAdd":
			cd = BlockDataviewRecordRelationOptionAdd(data)
		case "BlockDataviewRecordRelationOptionUpdate":
			cd = BlockDataviewRecordRelationOptionUpdate(data)
		case "BlockDataviewRecordRelationOptionDelete":
			cd = BlockDataviewRecordRelationOptionDelete(data)
		case "BlockObjectTypeSet":
			cd = BlockObjectTypeSet(data)
		case "NavigationListObjects":
			cd = NavigationListObjects(data)
		case "NavigationGetObjectInfoWithLinks":
			cd = NavigationGetObjectInfoWithLinks(data)
		case "ObjectSearch":
			cd = ObjectSearch(data)
		case "ObjectRelationAdd":
			cd = ObjectRelationAdd(data)
		case "ObjectRelationUpdate":
			cd = ObjectRelationUpdate(data)
		case "ObjectRelationDelete":
			cd = ObjectRelationDelete(data)
		case "ObjectRelationOptionAdd":
			cd = ObjectRelationOptionAdd(data)
		case "ObjectRelationOptionUpdate":
			cd = ObjectRelationOptionUpdate(data)
		case "ObjectRelationOptionDelete":
			cd = ObjectRelationOptionDelete(data)
		case "ObjectRelationListAvailable":
			cd = ObjectRelationListAvailable(data)
		case "BlockSetDetails":
			cd = BlockSetDetails(data)
		case "PageCreate":
			cd = PageCreate(data)
		case "SetCreate":
			cd = SetCreate(data)
		case "ObjectTypeCreate":
			cd = ObjectTypeCreate(data)
		case "ObjectTypeList":
			cd = ObjectTypeList(data)
		case "ObjectTypeRelationList":
			cd = ObjectTypeRelationList(data)
		case "ObjectTypeRelationAdd":
			cd = ObjectTypeRelationAdd(data)
		case "ObjectTypeRelationUpdate":
			cd = ObjectTypeRelationUpdate(data)
		case "ObjectTypeRelationRemove":
			cd = ObjectTypeRelationRemove(data)
		case "ObjectSetLayout":
			cd = ObjectSetLayout(data)
		case "ObjectFeaturedRelationAdd":
			cd = ObjectFeaturedRelationAdd(data)
		case "ObjectFeaturedRelationRemove":
			cd = ObjectFeaturedRelationRemove(data)
		case "Ping":
			cd = Ping(data)
		case "ProcessCancel":
			cd = ProcessCancel(data)
		case "HistoryShow":
			cd = HistoryShow(data)
		case "HistoryVersions":
			cd = HistoryVersions(data)
		case "HistorySetVersion":
			cd = HistorySetVersion(data)
		case "Export":
			cd = Export(data)
		case "ExportTemplates":
			cd = ExportTemplates(data)
		case "MakeTemplate":
			cd = MakeTemplate(data)
		case "MakeTemplateByObjectType":
			cd = MakeTemplateByObjectType(data)
		case "CloneTemplate":
			cd = CloneTemplate(data)
		case "ApplyTemplate":
			cd = ApplyTemplate(data)
		case "DebugSync":
			cd = DebugSync(data)
		case "DebugThread":
			cd = DebugThread(data)
		case "DebugTree":
			cd = DebugTree(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)
}