anyproto/anytype-heart
1
0
Fork 0
mirror of https://github.com/anyproto/anytype-heart.git synced 2025-06-11 18:20:33 +09:00
Code Activity

GO-2489 Merge branch 'main' of github.com:anyproto/anytype-heart into GO-2489-acl-architecture

Browse source
This commit is contained in:
Sergey 2024-02-08 17:22:00 +01:00
commit ad54eb8d54
No known key found for this signature in database
GPG key ID: 3B6BEF79160221C6
56 changed files with 5383 additions and 3085 deletions
Download patch file Download diff file Expand all files Collapse all files

604
clientlibrary/service/service.pb.go
View file

@ -25,277 +25,278 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
func init() { proto.RegisterFile("pb/protos/service/service.proto", fileDescriptor_93a29dc403579097) }
var fileDescriptor_93a29dc403579097 = []byte{
// 4306 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x9c, 0xcd, 0x6f, 0x24, 0x49,
0x56, 0xc0, 0xa7, 0x2e, 0x0c, 0xe4, 0xb2, 0xc3, 0x52, 0x0b, 0xc3, 0x6c, 0xb3, 0xeb, 0x9e, 0xe9,
0xe9, 0xb6, 0xbb, 0xdb, 0xed, 0x72, 0x4f, 0xf7, 0x4c, 0xcf, 0xb2, 0x8b, 0x84, 0xdc, 0x76, 0xdb,
0x63, 0xd6, 0x76, 0x1b, 0x97, 0xdd, 0x2d, 0x8d, 0x84, 0x44, 0x3a, 0x2b, 0x5c, 0x4e, 0x9c, 0x95,
0x91, 0x9b, 0x19, 0x55, 0xb6, 0x41, 0x20, 0x10, 0x08, 0x04, 0x02, 0x81, 0xf8, 0xba, 0x70, 0x40,
0xe2, 0x0f, 0xe1, 0x86, 0xc4, 0x71, 0x8e, 0x1c, 0xd1, 0xcc, 0x3f, 0x82, 0x32, 0xe2, 0x65, 0x7c,
0xbc, 0x8c, 0x17, 0x99, 0x35, 0x27, 0x5b, 0xf5, 0x7e, 0xef, 0x23, 0x32, 0x5e, 0x7c, 0x47, 0x66,
0x74, 0xb7, 0x38, 0xdf, 0x2c, 0x4a, 0x2e, 0x78, 0xb5, 0x59, 0xb1, 0x72, 0x91, 0x26, 0xac, 0xf9,
0x3b, 0x92, 0x3f, 0x0f, 0xdf, 0x8d, 0xf3, 0x5b, 0x71, 0x5b, 0xb0, 0x3b, 0x1f, 0x18, 0x32, 0xe1,
0xb3, 0x59, 0x9c, 0x4f, 0x2a, 0x85, 0xdc, 0x79, 0xdf, 0x48, 0xd8, 0x82, 0xe5, 0x02, 0x7e, 0x7f,
0xf6, 0xdf, 0xff, 0x35, 0x88, 0xde, 0xdb, 0xce, 0x52, 0x96, 0x8b, 0x6d, 0xd0, 0x18, 0x7e, 0x19,
0x7d, 0x77, 0xab, 0x28, 0xf6, 0x98, 0x78, 0xc3, 0xca, 0x2a, 0xe5, 0xf9, 0xf0, 0xe3, 0x11, 0x38,
0x18, 0x9d, 0x14, 0xc9, 0x68, 0xab, 0x28, 0x46, 0x46, 0x38, 0x3a, 0x61, 0x3f, 0x9f, 0xb3, 0x4a,
0xdc, 0xb9, 0x1f, 0x86, 0xaa, 0x82, 0xe7, 0x15, 0x1b, 0x5e, 0x44, 0xbf, 0xba, 0x55, 0x14, 0x63,
0x26, 0x76, 0x58, 0x5d, 0x80, 0xb1, 0x88, 0x05, 0x1b, 0xae, 0xb5, 0x54, 0x5d, 0x40, 0xfb, 0x78,
0xd8, 0x0d, 0x82, 0x9f, 0xd3, 0xe8, 0x3b, 0xb5, 0x9f, 0xcb, 0xb9, 0x98, 0xf0, 0xeb, 0x7c, 0xf8,
0x51, 0x5b, 0x11, 0x44, 0xda, 0xf6, 0xbd, 0x10, 0x02, 0x56, 0xdf, 0x46, 0xbf, 0xfc, 0x36, 0xce,
0x32, 0x26, 0xb6, 0x4b, 0x56, 0x07, 0xee, 0xea, 0x28, 0xd1, 0x48, 0xc9, 0xb4, 0xdd, 0x8f, 0x83,
0x0c, 0x18, 0xfe, 0x32, 0xfa, 0xae, 0x92, 0x9c, 0xb0, 0x84, 0x2f, 0x58, 0x39, 0xf4, 0x6a, 0x81,
0x90, 0x78, 0xe4, 0x2d, 0x08, 0xdb, 0xde, 0xe6, 0xf9, 0x82, 0x95, 0xc2, 0x6f, 0x1b, 0x84, 0x61,
0xdb, 0x06, 0x02, 0xdb, 0x7f, 0x33, 0x88, 0x7e, 0xb8, 0x95, 0x24, 0x7c, 0x9e, 0x8b, 0x03, 0x9e,
0xc4, 0xd9, 0x41, 0x9a, 0x5f, 0x1d, 0xb1, 0xeb, 0xed, 0xcb, 0x9a, 0xcf, 0xa7, 0x6c, 0xf8, 0xdc,
0x7d, 0xaa, 0x0a, 0x1d, 0x69, 0x76, 0x64, 0xc3, 0xda, 0xf7, 0xa7, 0xcb, 0x29, 0x41, 0x2c, 0xff,
0x30, 0x88, 0x56, 0x70, 0x2c, 0x63, 0x9e, 0x2d, 0x98, 0x89, 0xe6, 0xb3, 0x0e, 0xc3, 0x2e, 0xae,
0xe3, 0x79, 0xb1, 0xac, 0x1a, 0x44, 0x94, 0x45, 0xdf, 0xb7, 0xd3, 0x65, 0xcc, 0x2a, 0xd9, 0x9c,
0x1e, 0xd1, 0x19, 0x01, 0x88, 0xf6, 0xfc, 0xb8, 0x0f, 0x0a, 0xde, 0xd2, 0x68, 0x08, 0xde, 0x32,
0x5e, 0x69, 0x67, 0x0f, 0xbd, 0x16, 0x2c, 0x42, 0xfb, 0x7a, 0xd4, 0x83, 0x04, 0x57, 0x7f, 0x10,
0xfd, 0xca, 0x5b, 0x5e, 0x5e, 0x55, 0x45, 0x9c, 0x30, 0x68, 0x0a, 0x0f, 0x5c, 0xed, 0x46, 0x8a,
0x5b, 0xc3, 0x6a, 0x17, 0x66, 0x25, 0x6d, 0x23, 0x7c, 0x5d, 0x30, 0xdc, 0x07, 0x19, 0xc5, 0x5a,
0x48, 0x25, 0x2d, 0x86, 0xc0, 0xf6, 0x55, 0x34, 0x34, 0xb6, 0xcf, 0xff, 0x90, 0x25, 0x62, 0x6b,
0x32, 0xc1, 0xb5, 0x62, 0x74, 0x25, 0x31, 0xda, 0x9a, 0x4c, 0xa8, 0x5a, 0xf1, 0xa3, 0xe0, 0xec,
0x3a, 0x7a, 0x1f, 0x39, 0x3b, 0x48, 0x2b, 0xe9, 0x70, 0x23, 0x6c, 0x05, 0x30, 0xed, 0x74, 0xd4,
0x17, 0x07, 0xc7, 0x7f, 0x36, 0x88, 0x7e, 0xe0, 0xf1, 0x7c, 0xc2, 0x66, 0x7c, 0xc1, 0x86, 0x4f,
0xbb, 0xad, 0x29, 0x52, 0xfb, 0xff, 0x64, 0x09, 0x0d, 0x4f, 0x9a, 0x8c, 0x59, 0xc6, 0x12, 0x41,
0xa6, 0x89, 0x12, 0x77, 0xa6, 0x89, 0xc6, 0xac, 0x16, 0xd6, 0x08, 0xf7, 0x98, 0xd8, 0x9e, 0x97,
0x25, 0xcb, 0x05, 0x59, 0x97, 0x06, 0xe9, 0xac, 0x4b, 0x07, 0xf5, 0x94, 0x67, 0x8f, 0x89, 0xad,
0x2c, 0x23, 0xcb, 0xa3, 0xc4, 0x9d, 0xe5, 0xd1, 0x18, 0x78, 0x48, 0xa2, 0xef, 0x59, 0x4f, 0x4c,
0xec, 0xe7, 0x17, 0x7c, 0x48, 0x3f, 0x0b, 0x29, 0xd7, 0x3e, 0xd6, 0x3a, 0x39, 0x4f, 0x31, 0x5e,
0xdd, 0x14, 0xbc, 0xa4, 0xab, 0x45, 0x89, 0x3b, 0x8b, 0xa1, 0x31, 0xf0, 0xf0, 0xfb, 0xd1, 0x7b,
0xd0, 0x4b, 0x36, 0xe3, 0xd9, 0x7d, 0x6f, 0x17, 0x8a, 0x07, 0xb4, 0x07, 0x1d, 0x94, 0xe9, 0x1c,
0x40, 0x06, 0x9d, 0xcf, 0xc7, 0x5e, 0x3d, 0xd4, 0xf5, 0xdc, 0x0f, 0x43, 0x2d, 0xdb, 0x3b, 0x2c,
0x63, 0xa4, 0x6d, 0x25, 0xec, 0xb0, 0xad, 0x21, 0xb0, 0x5d, 0x46, 0xbf, 0xae, 0x1f, 0x4b, 0x3d,
0x8e, 0x4a, 0x79, 0xdd, 0x49, 0xaf, 0x13, 0xe5, 0xb6, 0x21, 0xed, 0xeb, 0x49, 0x3f, 0xb8, 0x55,
0x1e, 0x68, 0x81, 0xfe, 0xf2, 0xa0, 0xf6, 0x77, 0x3f, 0x0c, 0x81, 0xed, 0xbf, 0x1d, 0x44, 0x3f,
0x02, 0xd9, 0xab, 0x3c, 0x3e, 0xcf, 0x98, 0x1c, 0x12, 0x8f, 0x98, 0xb8, 0xe6, 0xe5, 0xd5, 0xf8,
0x36, 0x4f, 0x88, 0xe1, 0xdf, 0x0f, 0x77, 0x0c, 0xff, 0xa4, 0x92, 0x35, 0xe3, 0x83, 0x82, 0x0a,
0x5e, 0xe0, 0x19, 0x5f, 0x53, 0x02, 0xc1, 0x0b, 0x6a, 0xc6, 0xe7, 0x22, 0x2d, 0xab, 0x87, 0x75,
0xb7, 0xe9, 0xb7, 0x7a, 0x68, 0xf7, 0x93, 0xf7, 0x42, 0x88, 0xe9, 0xb6, 0x9a, 0x04, 0xe6, 0xf9,
0x45, 0x3a, 0x3d, 0x2b, 0x26, 0x75, 0x1a, 0x3f, 0xf2, 0x67, 0xa8, 0x85, 0x10, 0xdd, 0x16, 0x81,
0x82, 0xb7, 0xbf, 0x37, 0x13, 0x23, 0x68, 0x4a, 0xbb, 0x25, 0x9f, 0x1d, 0xb0, 0x69, 0x9c, 0xdc,
0x42, 0xfb, 0xff, 0x34, 0xd4, 0xf0, 0x30, 0xad, 0x83, 0xf8, 0x6c, 0x49, 0x2d, 0x88, 0xe7, 0x3f,
0x06, 0xd1, 0xfd, 0xa6, 0xf8, 0x97, 0x71, 0x3e, 0x65, 0x50, 0x9f, 0x2a, 0xfa, 0xad, 0x7c, 0x72,
0xc2, 0x2a, 0x11, 0x97, 0x62, 0xf8, 0x13, 0x7f, 0x21, 0x43, 0x3a, 0x3a, 0xb6, 0x9f, 0x7e, 0x2b,
0x5d, 0x53, 0xeb, 0xe3, 0xba, 0x63, 0x83, 0x2e, 0xc0, 0xad, 0x75, 0x29, 0xc1, 0x1d, 0xc0, 0xbd,
0x10, 0x62, 0x6a, 0x5d, 0x0a, 0xf6, 0xf3, 0x45, 0x2a, 0xd8, 0x1e, 0xcb, 0x59, 0xd9, 0xae, 0x75,
0xa5, 0xea, 0x22, 0x44, 0xad, 0x13, 0xa8, 0xe9, 0x6c, 0x1c, 0x6f, 0x7a, 0x70, 0x5c, 0x0f, 0x18,
0x69, 0x0d, 0x8f, 0x4f, 0xfa, 0xc1, 0x66, 0x75, 0x67, 0xf9, 0x3c, 0x61, 0x0b, 0x7e, 0x85, 0x57,
0x77, 0xb6, 0x09, 0x05, 0x10, 0xab, 0x3b, 0x2f, 0x68, 0x46, 0x30, 0xcb, 0xcf, 0x9b, 0x94, 0x5d,
0xa3, 0x11, 0xcc, 0x56, 0xae, 0xc5, 0xc4, 0x08, 0xe6, 0xc1, 0xc0, 0xc3, 0x51, 0xf4, 0x4b, 0x52,
0xf8, 0xbb, 0x3c, 0xcd, 0x87, 0x77, 0x3d, 0x4a, 0xb5, 0x40, 0x5b, 0xfd, 0x90, 0x06, 0x50, 0xc4,
0xf5, 0xaf, 0xdb, 0x71, 0x9e, 0xb0, 0xcc, 0x1b, 0xb1, 0x11, 0x07, 0x23, 0x76, 0x30, 0x14, 0xf1,
0xab, 0x9b, 0x54, 0x78, 0x23, 0xae, 0x05, 0xc1, 0x88, 0x01, 0x40, 0xd9, 0x0a, 0x1a, 0x5b, 0x45,
0x51, 0xd6, 0x3d, 0xa0, 0x2f, 0x5b, 0x5d, 0x24, 0x98, 0xad, 0x2d, 0xd4, 0xef, 0x6d, 0x87, 0x25,
0x59, 0x9a, 0x07, 0xbd, 0x01, 0xd2, 0xc7, 0x9b, 0x41, 0xc1, 0xdb, 0x3c, 0x7a, 0x5f, 0x02, 0xc7,
0x71, 0x29, 0xd2, 0x24, 0x2d, 0xe2, 0xbc, 0x99, 0x17, 0xfb, 0xf2, 0xbd, 0x45, 0x69, 0x9f, 0x1b,
0x3d, 0x69, 0x70, 0xfb, 0x6f, 0x83, 0xe8, 0x23, 0xec, 0xf7, 0x98, 0x95, 0xb3, 0x54, 0x2e, 0xaf,
0x2a, 0xd5, 0x39, 0x0d, 0x3f, 0x0f, 0x1b, 0x6d, 0x29, 0xe8, 0x68, 0x7e, 0xbc, 0xbc, 0x22, 0x04,
0xf6, 0x7b, 0x51, 0xa4, 0xa6, 0xf1, 0x72, 0xa9, 0xe5, 0xe6, 0x06, 0xcc, 0xef, 0x9d, 0x75, 0xd6,
0x47, 0x01, 0xc2, 0x74, 0xa1, 0xea, 0x77, 0xb9, 0x82, 0x1c, 0x7a, 0x35, 0xa4, 0x88, 0xe8, 0x42,
0x11, 0x82, 0x03, 0x1d, 0x5f, 0xf2, 0x6b, 0x7f, 0xa0, 0xb5, 0x24, 0x1c, 0x28, 0x10, 0x66, 0x4f,
0x07, 0x02, 0xf5, 0xed, 0xe9, 0x34, 0x61, 0x84, 0xf6, 0x74, 0x30, 0x03, 0x86, 0x79, 0xf4, 0x6b,
0xb6, 0xe1, 0x97, 0x9c, 0x5f, 0xcd, 0xe2, 0xf2, 0x6a, 0xf8, 0x98, 0x56, 0x6e, 0x18, 0xed, 0x68,
0xbd, 0x17, 0x6b, 0xda, 0x90, 0xed, 0xb0, 0x1e, 0x80, 0xcf, 0xca, 0x0c, 0xb5, 0x21, 0xc7, 0x06,
0x20, 0x44, 0x1b, 0x22, 0x50, 0xd3, 0xa3, 0xd9, 0xde, 0xc6, 0x0c, 0xaf, 0x22, 0x1c, 0xf5, 0x31,
0xa3, 0x56, 0x11, 0x1e, 0x0c, 0xa7, 0xd0, 0x5e, 0x19, 0x17, 0x97, 0xfe, 0x14, 0x92, 0xa2, 0x70,
0x0a, 0x35, 0x08, 0xae, 0xef, 0x31, 0x8b, 0xcb, 0xe4, 0xd2, 0x5f, 0xdf, 0x4a, 0x16, 0xae, 0x6f,
0xcd, 0x98, 0x01, 0xd7, 0x36, 0x3c, 0x9e, 0x9f, 0x57, 0x49, 0x99, 0x9e, 0xb3, 0xe1, 0x3a, 0xad,
0xad, 0x21, 0x62, 0xc0, 0x25, 0x61, 0xb3, 0xe7, 0x03, 0x3e, 0x1b, 0xd9, 0xfe, 0xa4, 0x42, 0x7b,
0x3e, 0x8d, 0x0d, 0x8b, 0x20, 0xf6, 0x7c, 0xfc, 0x24, 0x2e, 0xde, 0x5e, 0xc9, 0xe7, 0x45, 0xd5,
0x51, 0x3c, 0x04, 0x85, 0x8b, 0xd7, 0x86, 0xc1, 0xe7, 0x4d, 0xf4, 0x1b, 0xf6, 0x23, 0x3d, 0xcb,
0x2b, 0xed, 0x75, 0x83, 0x7e, 0x4e, 0x16, 0x46, 0xec, 0x9e, 0x04, 0x70, 0xb3, 0x10, 0x6f, 0x3c,
0x8b, 0x1d, 0x26, 0xe2, 0x34, 0xab, 0x86, 0xab, 0x7e, 0x1b, 0x8d, 0x9c, 0x58, 0x88, 0xfb, 0x38,
0xdc, 0x84, 0x76, 0xe6, 0x45, 0x96, 0x26, 0xed, 0x6d, 0x34, 0xd0, 0xd5, 0xe2, 0x70, 0x13, 0xb2,
0x31, 0xdc, 0x25, 0x8c, 0x99, 0x50, 0xff, 0x9c, 0xde, 0x16, 0xcc, 0xdf, 0x25, 0x38, 0x48, 0xb8,
0x4b, 0xc0, 0x28, 0x2e, 0xcf, 0x98, 0x89, 0x83, 0xf8, 0x96, 0xcf, 0x89, 0x2e, 0x41, 0x8b, 0xc3,
0xe5, 0xb1, 0x31, 0x33, 0x70, 0x6b, 0x0f, 0xfb, 0xb9, 0x60, 0x65, 0x1e, 0x67, 0xbb, 0x59, 0x3c,
0xad, 0x86, 0x44, 0xbb, 0x71, 0x29, 0x62, 0xe0, 0xa6, 0x69, 0xcf, 0x63, 0xdc, 0xaf, 0x76, 0xe3,
0x05, 0x2f, 0x53, 0x41, 0x3f, 0x46, 0x83, 0x74, 0x3e, 0x46, 0x07, 0xf5, 0x7a, 0xdb, 0x2a, 0x93,
0xcb, 0x74, 0xc1, 0x26, 0x01, 0x6f, 0x0d, 0xd2, 0xc3, 0x9b, 0x85, 0x7a, 0x2a, 0x6d, 0xcc, 0xe7,
0x65, 0xc2, 0xc8, 0x4a, 0x53, 0xe2, 0xce, 0x4a, 0xd3, 0x18, 0x78, 0xf8, 0xcb, 0x41, 0xf4, 0x9b,
0x4a, 0x6a, 0xef, 0x6d, 0xed, 0xc4, 0xd5, 0xe5, 0x39, 0x8f, 0xcb, 0xc9, 0xf0, 0x13, 0x9f, 0x1d,
0x2f, 0xaa, 0x5d, 0x3f, 0x5b, 0x46, 0x05, 0x3f, 0xd6, 0x83, 0xb4, 0xb2, 0x5a, 0x9c, 0xf7, 0xb1,
0x3a, 0x48, 0xf8, 0xb1, 0x62, 0x14, 0x77, 0x20, 0x52, 0xae, 0xd6, 0x91, 0xab, 0xa4, 0xbe, 0xbb,
0x98, 0x5c, 0xeb, 0xe4, 0x70, 0xff, 0x58, 0x0b, 0xdd, 0x6c, 0xd9, 0xa0, 0x6c, 0xf8, 0x33, 0x66,
0xd4, 0x17, 0x27, 0x3d, 0xeb, 0x56, 0x11, 0xf6, 0xdc, 0x6a, 0x19, 0xa3, 0xbe, 0x38, 0xe1, 0xd9,
0xea, 0xd6, 0x42, 0x9e, 0x3d, 0x5d, 0xdb, 0xa8, 0x2f, 0x8e, 0x13, 0x68, 0xab, 0x28, 0xb2, 0xdb,
0x53, 0x36, 0x2b, 0x32, 0x32, 0x81, 0x1c, 0x24, 0x9c, 0x40, 0x18, 0xc5, 0xb3, 0x9f, 0x53, 0x5e,
0xcf, 0xad, 0xbc, 0xb3, 0x1f, 0x29, 0x0a, 0xcf, 0x7e, 0x1a, 0x04, 0x4f, 0x18, 0x4e, 0xf9, 0x36,
0xcf, 0x32, 0x96, 0x88, 0xf6, 0x21, 0x91, 0xd6, 0x34, 0x44, 0x78, 0xc2, 0x80, 0x48, 0xb3, 0x19,
0xd0, 0xcc, 0xd5, 0xe3, 0x92, 0xbd, 0xbc, 0x3d, 0x48, 0xf3, 0xab, 0xa1, 0x7f, 0x6c, 0x34, 0x00,
0xb1, 0x19, 0xe0, 0x05, 0xf1, 0x9a, 0xe0, 0x2c, 0x9f, 0x70, 0xff, 0x9a, 0xa0, 0x96, 0x84, 0xd7,
0x04, 0x40, 0x60, 0x93, 0x27, 0x8c, 0x32, 0x59, 0x4b, 0xc2, 0x26, 0x81, 0xf0, 0xf5, 0x07, 0xb0,
0xeb, 0x46, 0xf6, 0x07, 0x68, 0x9f, 0x6d, 0xad, 0x93, 0xc3, 0x19, 0xda, 0x2c, 0x0e, 0x76, 0x99,
0x48, 0x2e, 0xfd, 0x19, 0xea, 0x20, 0xe1, 0x0c, 0xc5, 0x28, 0x2e, 0xd2, 0x29, 0xd7, 0x8b, 0x9b,
0x55, 0x7f, 0x7e, 0xb4, 0x16, 0x36, 0x6b, 0x9d, 0x1c, 0x9e, 0xae, 0xef, 0xcf, 0xe4, 0x33, 0xf3,
0x26, 0xb9, 0x92, 0x85, 0xa7, 0xeb, 0x9a, 0xc1, 0xd1, 0x2b, 0x41, 0xfd, 0x38, 0xfd, 0xd1, 0x1b,
0x79, 0x38, 0x7a, 0x87, 0x03, 0x27, 0xff, 0x32, 0x88, 0xee, 0xda, 0x5e, 0x8e, 0x78, 0xdd, 0x46,
0xde, 0xc4, 0x59, 0x3a, 0x89, 0x05, 0x3b, 0xe5, 0x57, 0x2c, 0x47, 0xeb, 0x7d, 0x37, 0x5a, 0xc5,
0x8f, 0x1c, 0x05, 0x62, 0xbd, 0xdf, 0x4b, 0x11, 0xe7, 0x89, 0xa2, 0xcf, 0x2a, 0xb6, 0x1d, 0x57,
0x44, 0x4f, 0xe6, 0x20, 0xe1, 0x3c, 0xc1, 0x28, 0x9e, 0xb4, 0x29, 0xf9, 0xab, 0x9b, 0x82, 0x95,
0x29, 0xcb, 0x13, 0xe6, 0x9f, 0xb4, 0x61, 0x2a, 0x3c, 0x69, 0xf3, 0xd0, 0xad, 0xe5, 0xb0, 0xee,
0x9c, 0xda, 0xe7, 0xbc, 0x98, 0x08, 0x9c, 0xf3, 0x12, 0x28, 0x2e, 0xa4, 0x01, 0xbc, 0x5b, 0x4a,
0x2d, 0x2b, 0xc1, 0x2d, 0x25, 0x9a, 0x6e, 0x6d, 0x32, 0x68, 0x66, 0x5c, 0x37, 0x93, 0x8e, 0xd0,
0xc7, 0x76, 0x73, 0x59, 0xef, 0xc5, 0xfa, 0x77, 0x35, 0x4e, 0x58, 0x16, 0xcb, 0x21, 0x24, 0xb0,
0x75, 0xd0, 0x30, 0x7d, 0x76, 0x35, 0x2c, 0x16, 0x1c, 0xfe, 0xf9, 0x20, 0xba, 0xe3, 0xf3, 0xf8,
0xba, 0x90, 0x7e, 0x9f, 0x76, 0xdb, 0x52, 0x24, 0x71, 0x90, 0x1d, 0xd6, 0x80, 0x18, 0xfe, 0x38,
0xfa, 0xa0, 0x11, 0x99, 0x73, 0x6e, 0x08, 0xc0, 0x9d, 0x45, 0xe8, 0xf8, 0x31, 0xa7, 0xdd, 0x6f,
0xf6, 0xe6, 0xcd, 0x04, 0xdd, 0x8d, 0xab, 0x42, 0x13, 0x74, 0x6d, 0x03, 0xc4, 0xc4, 0x04, 0xdd,
0x83, 0xe1, 0x91, 0xba, 0x41, 0xea, 0x76, 0xe2, 0xeb, 0xe3, 0xb4, 0x09, 0xbb, 0x95, 0x3c, 0xec,
0x06, 0x71, 0xee, 0x34, 0x62, 0x98, 0x17, 0x3f, 0x0e, 0x59, 0x40, 0x73, 0xe3, 0xf5, 0x5e, 0x2c,
0x38, 0xfc, 0xd3, 0xe8, 0x07, 0xad, 0x82, 0xed, 0xb2, 0x58, 0xcc, 0x4b, 0x36, 0x19, 0x6e, 0x76,
0xc4, 0xdd, 0x80, 0xda, 0xf5, 0xd3, 0xfe, 0x0a, 0xe0, 0xff, 0xaf, 0x07, 0xd1, 0x0f, 0x5d, 0x4e,
0x55, 0xb1, 0x8e, 0xe1, 0x59, 0xc8, 0xa4, 0xcb, 0xea, 0x30, 0x9e, 0x2f, 0xa5, 0xd3, 0x5a, 0x83,
0xd9, 0x89, 0xbc, 0xb5, 0x88, 0xd3, 0x2c, 0x3e, 0xcf, 0x98, 0x77, 0x0d, 0xe6, 0xe4, 0xa6, 0x46,
0x83, 0x6b, 0x30, 0x52, 0xa5, 0xd5, 0x4b, 0xca, 0xf6, 0x66, 0xcd, 0xdd, 0x9f, 0xd0, 0xad, 0xd2,
0x33, 0x75, 0xdf, 0xe8, 0x49, 0x83, 0x5b, 0xd1, 0xec, 0x5d, 0xd5, 0x3f, 0xdb, 0x49, 0xee, 0xf3,
0x0a, 0xaa, 0x9e, 0x4c, 0xdf, 0xe8, 0x49, 0x83, 0xd7, 0x3f, 0x89, 0x3e, 0x68, 0x7b, 0x85, 0x41,
0x61, 0xb3, 0xd3, 0x14, 0x1a, 0x17, 0x9e, 0xf6, 0x57, 0x30, 0x53, 0xfd, 0x2f, 0xd2, 0x4a, 0xf0,
0xf2, 0x76, 0x7c, 0xc9, 0xaf, 0x9b, 0xbb, 0x9c, 0x6e, 0x6b, 0x05, 0x60, 0x64, 0x11, 0xc4, 0x54,
0xdf, 0x4f, 0xb6, 0x5c, 0x99, 0x3b, 0x9f, 0x15, 0xe1, 0xca, 0x22, 0x3a, 0x5c, 0xb9, 0xa4, 0xe9,
0xab, 0x9a, 0x52, 0x99, 0x0b, 0xaa, 0x6b, 0xfe, 0x50, 0xdb, 0x97, 0x54, 0x1f, 0x76, 0x83, 0x66,
0xf9, 0xb5, 0x9b, 0x66, 0xec, 0xf5, 0xc5, 0x45, 0xc6, 0xe3, 0x09, 0x5a, 0x7e, 0xd5, 0x92, 0x11,
0x88, 0x88, 0xe5, 0x17, 0x42, 0xcc, 0xa4, 0xb3, 0x16, 0xc8, 0xb3, 0x99, 0xc6, 0xf4, 0x6a, 0x5b,
0xcf, 0x96, 0x13, 0x93, 0x4e, 0x1f, 0x67, 0x06, 0x8c, 0x5a, 0x5a, 0x37, 0xc1, 0xc6, 0xc7, 0x83,
0xb6, 0xae, 0x25, 0x26, 0x06, 0x0c, 0x0f, 0x66, 0xd6, 0x47, 0xb5, 0xf0, 0xac, 0x90, 0xc6, 0x3f,
0x6c, 0x6b, 0x29, 0x09, 0xb1, 0x3e, 0x72, 0x09, 0x33, 0xcf, 0xaf, 0x7f, 0xdf, 0xe1, 0xd7, 0xb9,
0x34, 0xea, 0x79, 0x9a, 0x8d, 0x8c, 0x98, 0xe7, 0x63, 0x06, 0x0c, 0xff, 0x2c, 0xfa, 0x45, 0x69,
0xb8, 0xe4, 0xc5, 0x70, 0xc5, 0xa3, 0x50, 0x5a, 0x37, 0x42, 0xee, 0x92, 0x72, 0x73, 0xb1, 0x49,
0xd7, 0xdf, 0x59, 0x15, 0x4f, 0x19, 0xba, 0xd8, 0x64, 0x6a, 0x45, 0x4a, 0x89, 0x8b, 0x4d, 0x6d,
0xca, 0x5c, 0xd6, 0xa9, 0x65, 0x47, 0x7c, 0x02, 0xd6, 0x3d, 0x25, 0xd4, 0x42, 0xe2, 0xb2, 0x4e,
0x0b, 0x32, 0xfb, 0xf7, 0x47, 0xf1, 0x22, 0x9d, 0xea, 0xce, 0x5f, 0xf5, 0x21, 0x15, 0xda, 0xbf,
0x37, 0xcc, 0xc8, 0x82, 0x88, 0xfd, 0x7b, 0x12, 0x06, 0x9f, 0xff, 0x3c, 0x88, 0x3e, 0x34, 0xcc,
0x5e, 0xb3, 0xad, 0xb2, 0x9f, 0x5f, 0xf0, 0xb7, 0xa9, 0xb8, 0xac, 0xd7, 0xf1, 0xd5, 0xf0, 0x05,
0x65, 0xd2, 0xcf, 0xeb, 0x50, 0x3e, 0x5f, 0x5a, 0xcf, 0xcc, 0xe6, 0x9a, 0xed, 0x16, 0x73, 0xb6,
0xa5, 0x34, 0xd0, 0x6c, 0x4e, 0xef, 0xca, 0x60, 0x8e, 0x98, 0xcd, 0x85, 0x78, 0x53, 0xc5, 0xda,
0x79, 0xc6, 0x73, 0x5c, 0xc5, 0xc6, 0x42, 0x2d, 0x24, 0xaa, 0xb8, 0x05, 0x99, 0xbe, 0xb1, 0x11,
0xa9, 0x9d, 0x81, 0xad, 0x2c, 0x43, 0x7d, 0xa3, 0x56, 0xd5, 0x00, 0xd1, 0x37, 0x7a, 0x41, 0xf0,
0x73, 0x12, 0x7d, 0xa7, 0x7e, 0xa4, 0xc7, 0x25, 0x5b, 0xa4, 0x0c, 0x1f, 0xc3, 0x5a, 0x12, 0xa2,
0xfd, 0xbb, 0x84, 0x69, 0x59, 0x67, 0x79, 0x55, 0x64, 0x71, 0x75, 0x09, 0x07, 0x73, 0x6e, 0x99,
0x1b, 0x21, 0x3e, 0x9a, 0x7b, 0xd0, 0x41, 0x99, 0x8e, 0xb7, 0x91, 0xe9, 0x2e, 0x66, 0xd5, 0xaf,
0xda, 0xea, 0x66, 0xd6, 0x3a, 0x39, 0x70, 0x12, 0x47, 0xdf, 0x6b, 0x7e, 0x3c, 0x8c, 0xf3, 0xf4,
0x82, 0x55, 0xf8, 0x00, 0x04, 0x8b, 0x89, 0x9e, 0xd7, 0x83, 0x99, 0x61, 0xe9, 0x65, 0xc6, 0x93,
0x2b, 0xe8, 0x7a, 0xdd, 0x07, 0x2b, 0x25, 0xb8, 0xef, 0xbd, 0x17, 0x42, 0x4c, 0xe7, 0x2b, 0x05,
0x27, 0xac, 0xc8, 0xe2, 0x04, 0x9f, 0x81, 0x2b, 0x1d, 0x90, 0x11, 0x9d, 0x2f, 0x66, 0x50, 0xb8,
0x70, 0xb6, 0xee, 0x0b, 0x17, 0x1d, 0xad, 0xdf, 0x0b, 0x21, 0x66, 0xf8, 0x91, 0x82, 0x71, 0x91,
0xa5, 0x02, 0xa5, 0x9f, 0xd2, 0x90, 0x12, 0x22, 0xfd, 0x5c, 0x02, 0x99, 0x3c, 0x64, 0xe5, 0x94,
0x79, 0x4d, 0x4a, 0x49, 0xd0, 0x64, 0x43, 0x98, 0x0b, 0x39, 0xaa, 0xec, 0xbc, 0xb8, 0x45, 0x17,
0x72, 0xa0, 0x58, 0xbc, 0xb8, 0x25, 0x2e, 0xe4, 0x38, 0x00, 0x0a, 0xf1, 0x38, 0xae, 0x84, 0x3f,
0x44, 0x29, 0x09, 0x86, 0xd8, 0x10, 0x66, 0x6c, 0x54, 0x21, 0xce, 0x05, 0x1a, 0x1b, 0x21, 0x00,
0xeb, 0x88, 0xee, 0x2e, 0x29, 0x37, 0x2d, 0x58, 0xd5, 0x0a, 0x13, 0xbb, 0x29, 0xcb, 0x26, 0x15,
0x6a, 0xc1, 0xf0, 0xdc, 0x1b, 0x29, 0xd1, 0x82, 0xdb, 0x14, 0x4a, 0x25, 0xd8, 0x3b, 0xf5, 0x95,
0x0e, 0x6d, 0x9b, 0xde, 0x0b, 0x21, 0xa6, 0x5f, 0x68, 0x82, 0xde, 0x8e, 0xcb, 0x32, 0xad, 0x07,
0xdd, 0x55, 0x7f, 0x40, 0x8d, 0x9c, 0xe8, 0x17, 0x7c, 0x1c, 0x6a, 0x5e, 0x4d, 0x87, 0xe9, 0x0b,
0x0c, 0x77, 0x99, 0x1f, 0x07, 0x19, 0x33, 0xd3, 0x93, 0x12, 0xeb, 0x8c, 0xc9, 0xf7, 0x34, 0x3d,
0x47, 0x4c, 0xab, 0x5d, 0x98, 0x75, 0xc5, 0x57, 0xbb, 0x38, 0xe4, 0x0b, 0x76, 0xca, 0x5f, 0xdd,
0xa4, 0x95, 0x48, 0xf3, 0x29, 0x8c, 0x98, 0xcf, 0x09, 0x4b, 0x3e, 0x98, 0xb8, 0xe2, 0xdb, 0xa9,
0x64, 0x06, 0x6e, 0x14, 0xcb, 0x11, 0xbb, 0xf6, 0x0e, 0xdc, 0xd8, 0xa2, 0xe6, 0x88, 0x81, 0x3b,
0xc4, 0x9b, 0xbd, 0x04, 0xed, 0x1c, 0xde, 0x83, 0x3a, 0xe5, 0xcd, 0x1c, 0x8a, 0xb2, 0x86, 0x41,
0x62, 0x39, 0x17, 0x54, 0x30, 0x6b, 0x2c, 0xed, 0xdf, 0x34, 0xb1, 0x87, 0x84, 0x9d, 0x76, 0x33,
0x7b, 0xd4, 0x83, 0xf4, 0xb8, 0x32, 0x07, 0xa5, 0x94, 0xab, 0xf6, 0x39, 0xe9, 0xa3, 0x1e, 0xa4,
0xb5, 0x2f, 0x61, 0x17, 0xeb, 0x65, 0x9c, 0x5c, 0x4d, 0x4b, 0x3e, 0xcf, 0x27, 0xdb, 0x3c, 0xe3,
0x25, 0xda, 0x97, 0x70, 0xa2, 0x46, 0x28, 0xb1, 0x2f, 0xd1, 0xa1, 0x62, 0x66, 0x4e, 0x76, 0x14,
0x5b, 0x59, 0x3a, 0xc5, 0xab, 0x4a, 0xc7, 0x90, 0x04, 0x88, 0x99, 0x93, 0x17, 0xf4, 0x24, 0x91,
0x5a, 0x75, 0x8a, 0x34, 0x89, 0x33, 0xe5, 0x6f, 0x93, 0x36, 0xe3, 0x80, 0x9d, 0x49, 0xe4, 0x51,
0xf0, 0x94, 0xf3, 0x74, 0x5e, 0xe6, 0xfb, 0xb9, 0xe0, 0x64, 0x39, 0x1b, 0xa0, 0xb3, 0x9c, 0x16,
0x88, 0xba, 0xd5, 0x53, 0x76, 0x53, 0x47, 0x53, 0xff, 0xf1, 0x75, 0xab, 0xf5, 0xef, 0x23, 0x90,
0x87, 0xba, 0x55, 0xc4, 0xa1, 0xc2, 0x80, 0x13, 0x95, 0x30, 0x01, 0x6d, 0x37, 0x4d, 0x1e, 0x76,
0x83, 0x7e, 0x3f, 0x63, 0x71, 0x9b, 0xb1, 0x90, 0x1f, 0x09, 0xf4, 0xf1, 0xd3, 0x80, 0xe6, 0xc0,
0xc2, 0x29, 0xcf, 0x25, 0x4b, 0xae, 0x5a, 0xf7, 0x3e, 0xdc, 0x40, 0x15, 0x42, 0x1c, 0x58, 0x10,
0xa8, 0xbf, 0x8a, 0xf6, 0x13, 0x9e, 0x87, 0xaa, 0xa8, 0x96, 0xf7, 0xa9, 0x22, 0xe0, 0xcc, 0xa2,
0x53, 0x4b, 0x21, 0x33, 0x55, 0x35, 0xad, 0x13, 0x16, 0x6c, 0x88, 0x58, 0x74, 0x92, 0xb0, 0xd9,
0x65, 0xc6, 0x3e, 0x0f, 0xdb, 0xf7, 0x2e, 0x5b, 0x56, 0x0e, 0xe9, 0x7b, 0x97, 0x14, 0x4b, 0x17,
0x52, 0xe5, 0x48, 0x87, 0x15, 0x37, 0x4f, 0x9e, 0xf4, 0x83, 0xcd, 0x2d, 0x08, 0xc7, 0xe7, 0x76,
0xc6, 0xe2, 0x52, 0x79, 0xdd, 0x08, 0x18, 0x32, 0x18, 0x71, 0x0b, 0x22, 0x80, 0xa3, 0x2e, 0xcc,
0xf1, 0xbc, 0xcd, 0x73, 0xc1, 0x72, 0xe1, 0xeb, 0xc2, 0x5c, 0x63, 0x00, 0x86, 0xba, 0x30, 0x4a,
0x01, 0xe5, 0xad, 0xdc, 0x87, 0x61, 0xe2, 0x28, 0x9e, 0x79, 0x67, 0x6c, 0x6a, 0x8f, 0x45, 0xc9,
0x43, 0x79, 0x8b, 0x38, 0xd4, 0xe4, 0xf7, 0x67, 0xf1, 0x54, 0x7b, 0xf1, 0x68, 0x4b, 0x79, 0xcb,
0xcd, 0xc3, 0x6e, 0x10, 0xf9, 0x79, 0x93, 0x4e, 0x18, 0x0f, 0xf8, 0x91, 0xf2, 0x3e, 0x7e, 0x30,
0x88, 0x66, 0x4e, 0x75, 0x69, 0xd5, 0x6a, 0x6a, 0x2b, 0x9f, 0xc0, 0x1a, 0x72, 0x44, 0x3c, 0x14,
0xc4, 0x85, 0x66, 0x4e, 0x04, 0x8f, 0xda, 0x47, 0xb3, 0x29, 0x19, 0x6a, 0x1f, 0x7a, 0xcf, 0xb1,
0x4f, 0xfb, 0xf0, 0xc1, 0xe0, 0xf3, 0x8f, 0xa0, 0x7d, 0xec, 0xc4, 0x22, 0xae, 0xe7, 0xcc, 0x6f,
0x52, 0x76, 0x0d, 0x8b, 0x50, 0x4f, 0x79, 0x1b, 0x6a, 0x24, 0x5f, 0x02, 0x41, 0x2b, 0xd2, 0xcd,
0xde, 0x7c, 0xc0, 0x37, 0xcc, 0xce, 0x3b, 0x7d, 0xa3, 0x69, 0xfa, 0x66, 0x6f, 0x3e, 0xe0, 0x1b,
0xde, 0x2e, 0xeb, 0xf4, 0x8d, 0x5e, 0x31, 0xdb, 0xec, 0xcd, 0x83, 0xef, 0xbf, 0x18, 0x44, 0x77,
0x5a, 0xce, 0xeb, 0x39, 0x50, 0x22, 0xd2, 0x05, 0xf3, 0x4d, 0xe5, 0x5c, 0x7b, 0x1a, 0x0d, 0x4d,
0xe5, 0x68, 0x15, 0xeb, 0x93, 0x04, 0xbe, 0x28, 0x8e, 0x79, 0x95, 0xca, 0x03, 0xdb, 0xe7, 0x3d,
0x8c, 0x36, 0x70, 0x68, 0xc1, 0x12, 0x52, 0x32, 0xc7, 0x5d, 0x0e, 0x6a, 0xae, 0x58, 0x3e, 0x09,
0xd8, 0x6b, 0xdf, 0xb4, 0xdc, 0xe8, 0x49, 0x9b, 0x83, 0x27, 0x87, 0xb1, 0x4f, 0xbc, 0x42, 0xb5,
0xea, 0x3d, 0xf4, 0x7a, 0xda, 0x5f, 0x01, 0xdc, 0xff, 0x55, 0x33, 0xa7, 0xc7, 0xfe, 0xa1, 0x11,
0x3c, 0xeb, 0x63, 0x11, 0x35, 0x84, 0xe7, 0x4b, 0xe9, 0x40, 0x20, 0xff, 0x3e, 0x88, 0xee, 0x79,
0x03, 0x71, 0xcf, 0x3e, 0x7f, 0xab, 0x8f, 0x6d, 0xff, 0x19, 0xe8, 0x4f, 0xbe, 0x8d, 0x2a, 0x44,
0xf7, 0x77, 0xcd, 0xd2, 0xba, 0xd1, 0x90, 0xd7, 0xe0, 0x5f, 0x97, 0x13, 0x56, 0x42, 0x8b, 0x0d,
0x25, 0x9d, 0x81, 0x71, 0xbb, 0xfd, 0x6c, 0x49, 0x2d, 0xeb, 0xf3, 0x19, 0x0e, 0x0c, 0x6f, 0x04,
0x59, 0xf1, 0x84, 0x2c, 0x5b, 0x34, 0x0e, 0xe8, 0xc5, 0xb2, 0x6a, 0x54, 0x4b, 0xb6, 0x60, 0xf9,
0x36, 0xee, 0xf3, 0x9e, 0x86, 0x9d, 0xf7, 0x73, 0x3f, 0x5d, 0x4e, 0x09, 0x62, 0xf9, 0xcf, 0x41,
0xf4, 0xc0, 0x61, 0xcd, 0x0e, 0x3f, 0xda, 0x0f, 0xf9, 0x69, 0xc0, 0x3e, 0xa5, 0xa4, 0x83, 0xfb,
0xed, 0x6f, 0xa7, 0x6c, 0xbe, 0x35, 0xe1, 0xa8, 0xec, 0xa6, 0x99, 0x60, 0x65, 0xfb, 0x5b, 0x13,
0xae, 0x5d, 0x45, 0x8d, 0xe8, 0x6f, 0x4d, 0x04, 0x70, 0xeb, 0x5b, 0x13, 0x1e, 0xcf, 0xde, 0x6f,
0x4d, 0x78, 0xad, 0x05, 0xbf, 0x35, 0x11, 0xd6, 0xa0, 0x06, 0x9f, 0x26, 0x04, 0xb5, 0xa3, 0xdd,
0xcb, 0xa2, 0xbb, 0xc1, 0xfd, 0x6c, 0x19, 0x15, 0x62, 0xf8, 0x55, 0x9c, 0xbc, 0x91, 0xd5, 0xe3,
0x99, 0x3a, 0xb7, 0xb2, 0x36, 0x7b, 0xf3, 0xe0, 0xfb, 0xe7, 0xb0, 0xee, 0xd1, 0x83, 0x0d, 0x2f,
0xe5, 0x77, 0x46, 0xd6, 0x43, 0x83, 0x47, 0x6d, 0xc1, 0xae, 0xf9, 0x27, 0xfd, 0x60, 0xa2, 0xb8,
0x35, 0x01, 0x95, 0x3e, 0xea, 0x32, 0x84, 0xaa, 0x7c, 0xb3, 0x37, 0x4f, 0x0c, 0x72, 0xca, 0xb7,
0xaa, 0xed, 0x1e, 0xc6, 0xdc, 0xba, 0x7e, 0xda, 0x5f, 0xc1, 0x5c, 0x29, 0x69, 0xb9, 0x97, 0xf5,
0xdc, 0xf9, 0x04, 0x9d, 0x5a, 0xde, 0xe8, 0x49, 0x87, 0x26, 0x37, 0xf6, 0xf0, 0xde, 0x35, 0xb9,
0xf1, 0x0e, 0xf1, 0x9f, 0x2e, 0xa7, 0x04, 0xb1, 0xfc, 0xd3, 0x20, 0xba, 0x4b, 0xc6, 0x02, 0x59,
0xf0, 0xa2, 0xaf, 0x65, 0x94, 0x0d, 0x9f, 0x2f, 0xad, 0x07, 0x41, 0xfd, 0xeb, 0x20, 0xfa, 0x30,
0x10, 0x94, 0x4a, 0x8f, 0x25, 0xac, 0xbb, 0x69, 0xf2, 0xe3, 0xe5, 0x15, 0xa9, 0xc1, 0xde, 0xc6,
0xc7, 0xed, 0x4f, 0x30, 0x04, 0x6c, 0x8f, 0xe9, 0x4f, 0x30, 0x74, 0x6b, 0xe1, 0xcd, 0x9f, 0x7a,
0x4a, 0x02, 0xeb, 0x22, 0xdf, 0xe6, 0x8f, 0x9c, 0xb1, 0xa0, 0xf5, 0xd0, 0x5a, 0x27, 0xe7, 0x73,
0xf2, 0xea, 0xa6, 0x88, 0xf3, 0x09, 0xed, 0x44, 0xc9, 0xbb, 0x9d, 0x68, 0x0e, 0x6f, 0x9a, 0xd5,
0xd2, 0x13, 0xde, 0x2c, 0xf2, 0x1e, 0x51, 0xfa, 0x1a, 0x09, 0x6e, 0x9a, 0xb5, 0x50, 0xc2, 0x1b,
0xcc, 0x68, 0x43, 0xde, 0xd0, 0x44, 0xf6, 0x71, 0x1f, 0x14, 0x2d, 0x1f, 0xb4, 0x37, 0xbd, 0x17,
0xff, 0x24, 0x64, 0xa5, 0xb5, 0x1f, 0xbf, 0xd1, 0x93, 0x26, 0xdc, 0x8e, 0x99, 0xf8, 0x82, 0xc5,
0x13, 0x56, 0x06, 0xdd, 0x6a, 0xaa, 0x97, 0x5b, 0x9b, 0xf6, 0xb9, 0xdd, 0xe6, 0xd9, 0x7c, 0x96,
0x43, 0x65, 0x92, 0x6e, 0x6d, 0xaa, 0xdb, 0x2d, 0xa2, 0xf1, 0x76, 0xa1, 0x71, 0x2b, 0x27, 0x97,
0x8f, 0xc3, 0x66, 0x9c, 0x39, 0xe5, 0x7a, 0x2f, 0x96, 0x2e, 0x27, 0xa4, 0x51, 0x47, 0x39, 0x51,
0x26, 0x6d, 0xf4, 0xa4, 0xf1, 0xbe, 0x9d, 0xe5, 0x56, 0xe7, 0xd3, 0x66, 0x87, 0xad, 0x56, 0x4a,
0x3d, 0xed, 0xaf, 0x80, 0x77, 0x49, 0x21, 0xab, 0xea, 0x55, 0xd1, 0x6e, 0x9a, 0x65, 0xc3, 0xf5,
0x40, 0x9a, 0x34, 0x50, 0x70, 0x97, 0xd4, 0x03, 0x13, 0x99, 0xdc, 0xec, 0x2a, 0xe6, 0xc3, 0x2e,
0x3b, 0x92, 0xea, 0x95, 0xc9, 0x36, 0x8d, 0x76, 0xdb, 0xac, 0x47, 0xad, 0x4b, 0x3b, 0x0a, 0x3f,
0xb8, 0x56, 0x81, 0x37, 0x7b, 0xf3, 0xe8, 0x18, 0x5e, 0x52, 0x72, 0x64, 0xb9, 0x4f, 0x99, 0x70,
0x46, 0x92, 0x07, 0x1d, 0x14, 0xda, 0xb1, 0x54, 0xcd, 0xe8, 0x6d, 0x3a, 0x99, 0x32, 0xe1, 0x3d,
0x41, 0xb2, 0x81, 0xe0, 0x09, 0x12, 0x02, 0x51, 0xd5, 0xa9, 0xdf, 0xc7, 0x4c, 0x9c, 0xc6, 0xe5,
0x94, 0x89, 0xfd, 0x89, 0xaf, 0xea, 0x40, 0xd9, 0xa2, 0x42, 0x55, 0xe7, 0xa5, 0x51, 0x6f, 0xa0,
0xdd, 0xc2, 0x7b, 0xcc, 0x8f, 0x43, 0x66, 0xd0, 0xcb, 0xcc, 0xeb, 0xbd, 0x58, 0x34, 0xa2, 0x18,
0x87, 0xe9, 0x2c, 0x15, 0xbe, 0x11, 0xc5, 0xb2, 0x51, 0x23, 0xa1, 0x11, 0xa5, 0x8d, 0x52, 0xc5,
0xab, 0xe7, 0x08, 0xfb, 0x93, 0x70, 0xf1, 0x14, 0xd3, 0xaf, 0x78, 0x9a, 0x6d, 0x1d, 0x78, 0xe6,
0x3a, 0x65, 0xc4, 0x25, 0x2c, 0x95, 0x3d, 0xb9, 0x2d, 0x5f, 0xed, 0xc3, 0x60, 0xa8, 0xd7, 0xa1,
0x14, 0xac, 0xb7, 0x47, 0x34, 0xd7, 0x9c, 0xc9, 0x16, 0x05, 0x8b, 0xcb, 0x38, 0x4f, 0xbc, 0x4b,
0x53, 0x69, 0xb0, 0x45, 0x86, 0x96, 0xa6, 0xa4, 0x06, 0x3a, 0x4e, 0x77, 0x5f, 0xca, 0xf3, 0x34,
0x05, 0xfd, 0xf6, 0x9b, 0xfb, 0x4e, 0xde, 0xa3, 0x1e, 0x24, 0x3e, 0x4e, 0x6f, 0x00, 0xbd, 0x29,
0xaf, 0x9c, 0x7e, 0x12, 0x30, 0xe5, 0xa2, 0xa1, 0x65, 0x30, 0xad, 0x82, 0x92, 0x5a, 0x4f, 0x70,
0x99, 0xf8, 0x19, 0xbb, 0xf5, 0x25, 0xb5, 0x99, 0x9f, 0x4a, 0x24, 0x94, 0xd4, 0x6d, 0x14, 0xcd,
0x33, 0xed, 0x75, 0xd0, 0x6a, 0x40, 0xdf, 0x5e, 0xfa, 0xac, 0x75, 0x72, 0xa8, 0xe5, 0xec, 0xa4,
0x0b, 0xe7, 0x0c, 0xc3, 0x13, 0xe8, 0x4e, 0xba, 0xf0, 0x1f, 0x61, 0xac, 0xf7, 0x62, 0xf1, 0x51,
0x7d, 0x2c, 0xd8, 0x4d, 0x73, 0x86, 0xee, 0x09, 0x57, 0xca, 0x5b, 0x87, 0xe8, 0x0f, 0xbb, 0x41,
0x73, 0x21, 0xf5, 0xb8, 0xe4, 0x09, 0xab, 0x2a, 0xf8, 0x2e, 0x95, 0x7b, 0xf3, 0x08, 0x64, 0x23,
0xf4, 0x55, 0xaa, 0xfb, 0x61, 0x08, 0x6c, 0x7f, 0x11, 0xbd, 0x7b, 0xc0, 0xa7, 0x63, 0x96, 0x4f,
0x86, 0x3f, 0x72, 0xaf, 0x80, 0xf2, 0xe9, 0xa8, 0xfe, 0x59, 0xdb, 0x5b, 0xa1, 0xc4, 0xe6, 0x32,
0xdd, 0x0e, 0x3b, 0x9f, 0x4f, 0x4f, 0x4b, 0xc6, 0xd0, 0x65, 0x3a, 0xf9, 0xfb, 0xa8, 0x16, 0x10,
0x97, 0xe9, 0x1c, 0xc0, 0x8c, 0x92, 0xda, 0x5e, 0x3d, 0x11, 0xc5, 0x97, 0xd5, 0x8c, 0x8e, 0x94,
0x12, 0xa3, 0x64, 0x9b, 0x32, 0x95, 0x27, 0x65, 0xf2, 0x92, 0xf7, 0x78, 0x3e, 0x9b, 0xc5, 0xe5,
0x2d, 0xaa, 0x3c, 0xa5, 0x6b, 0x03, 0x44, 0xe5, 0x79, 0x41, 0x93, 0x95, 0xca, 0x8f, 0x88, 0x93,
0xab, 0x3d, 0x5e, 0xf2, 0xb9, 0x48, 0x73, 0x56, 0xa1, 0xac, 0x04, 0x0b, 0x2e, 0x43, 0x64, 0x25,
0xc5, 0x9a, 0x59, 0x9c, 0x24, 0xd4, 0x3d, 0x3a, 0xf9, 0x35, 0xc6, 0x4a, 0xf0, 0x12, 0x9f, 0xe5,
0x29, 0x2b, 0x18, 0x22, 0x66, 0x71, 0x24, 0x8c, 0xea, 0xfe, 0x38, 0xcd, 0xa7, 0xde, 0xba, 0xaf,
0x05, 0xc1, 0xba, 0x07, 0xc0, 0xf4, 0xc7, 0xea, 0xa1, 0xa9, 0xcf, 0xbe, 0xc0, 0x3b, 0x75, 0xde,
0x87, 0x6e, 0x13, 0x44, 0x7f, 0xec, 0x27, 0x91, 0xab, 0xd7, 0x05, 0xcb, 0xd9, 0xa4, 0xb9, 0x2d,
0xe6, 0x73, 0xe5, 0x10, 0x41, 0x57, 0x98, 0x34, 0xa9, 0x70, 0xc8, 0x44, 0x99, 0x26, 0xd5, 0x98,
0x89, 0xe3, 0xb8, 0x8c, 0x67, 0x4c, 0xb0, 0x12, 0xa7, 0x02, 0x20, 0x23, 0x87, 0x21, 0x52, 0x81,
0x62, 0xc1, 0xe1, 0xef, 0x44, 0xdf, 0xaf, 0x7b, 0x2e, 0x96, 0xc3, 0xe7, 0xa1, 0x5f, 0xc9, 0xef,
0xca, 0x0f, 0xdf, 0xd7, 0x36, 0xc6, 0xa2, 0x64, 0xf1, 0xac, 0xb1, 0xfd, 0x9e, 0xfe, 0x5d, 0x82,
0x4f, 0x07, 0x75, 0xbf, 0x7d, 0xc4, 0x45, 0x7a, 0x51, 0x2f, 0x14, 0xe0, 0x50, 0x06, 0xf5, 0xdb,
0xb6, 0x78, 0x14, 0x78, 0x03, 0xdb, 0xc7, 0x99, 0x96, 0x68, 0x4b, 0x4f, 0x58, 0x91, 0xe1, 0x96,
0xe8, 0x68, 0x4b, 0x80, 0x68, 0x89, 0x5e, 0x50, 0xf9, 0x79, 0xf9, 0xd1, 0xff, 0x7c, 0xbd, 0x32,
0xf8, 0xea, 0xeb, 0x95, 0xc1, 0xff, 0x7d, 0xbd, 0x32, 0xf8, 0xc7, 0x6f, 0x56, 0xde, 0xf9, 0xea,
0x9b, 0x95, 0x77, 0xfe, 0xf7, 0x9b, 0x95, 0x77, 0xbe, 0x7c, 0x17, 0x3e, 0xd6, 0x7f, 0xfe, 0x0b,
0xf2, 0x93, 0xfb, 0xcf, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x92, 0xf0, 0xa1, 0xf5, 0xd0, 0x5f,
0x00, 0x00,
// 4333 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x9d, 0xdd, 0x6f, 0x25, 0x47,
0x56, 0xc0, 0x73, 0x5f, 0x08, 0xf4, 0xb2, 0x01, 0xee, 0x42, 0xc8, 0x0e, 0xbb, 0x9e, 0x64, 0x32,
0x63, 0xcf, 0x8c, 0xc7, 0xd7, 0x93, 0x99, 0x64, 0xb2, 0xec, 0x22, 0x21, 0x8f, 0x3d, 0x76, 0xcc,
0xda, 0x1e, 0xe3, 0x6b, 0xcf, 0x48, 0x91, 0x90, 0x68, 0xf7, 0x2d, 0x5f, 0x37, 0xee, 0xdb, 0xd5,
0xdb, 0x5d, 0xf7, 0xda, 0x06, 0x81, 0x40, 0x20, 0x10, 0x08, 0x04, 0xe2, 0xeb, 0x85, 0x07, 0x24,
0xfe, 0x11, 0x5e, 0x79, 0x41, 0xca, 0x23, 0x8f, 0x28, 0xf9, 0x47, 0x56, 0x5d, 0x75, 0xba, 0x3e,
0x4e, 0xd7, 0xa9, 0xee, 0x9b, 0xa7, 0x89, 0x7c, 0x7e, 0xe7, 0xa3, 0xba, 0x4e, 0x55, 0x9d, 0xaa,
0xea, 0xdb, 0x89, 0xee, 0x16, 0xe7, 0x9b, 0x45, 0xc9, 0x05, 0xaf, 0x36, 0x2b, 0x56, 0x2e, 0xd2,
0x84, 0x35, 0xff, 0x8e, 0xe4, 0x9f, 0x87, 0xef, 0xc6, 0xf9, 0xad, 0xb8, 0x2d, 0xd8, 0x9d, 0x0f,
0x0c, 0x99, 0xf0, 0xd9, 0x2c, 0xce, 0x27, 0x95, 0x42, 0xee, 0xbc, 0x6f, 0x24, 0x6c, 0xc1, 0x72,
0x01, 0x7f, 0x7f, 0xf6, 0xbf, 0xff, 0x3d, 0x88, 0xde, 0xdb, 0xce, 0x52, 0x96, 0x8b, 0x6d, 0xd0,
0x18, 0x7e, 0x19, 0x7d, 0x77, 0xab, 0x28, 0xf6, 0x98, 0x78, 0xc3, 0xca, 0x2a, 0xe5, 0xf9, 0xf0,
0xe3, 0x11, 0x38, 0x18, 0x9d, 0x14, 0xc9, 0x68, 0xab, 0x28, 0x46, 0x46, 0x38, 0x3a, 0x61, 0x3f,
0x9b, 0xb3, 0x4a, 0xdc, 0xb9, 0x1f, 0x86, 0xaa, 0x82, 0xe7, 0x15, 0x1b, 0x5e, 0x44, 0xbf, 0xb6,
0x55, 0x14, 0x63, 0x26, 0x76, 0x58, 0xdd, 0x80, 0xb1, 0x88, 0x05, 0x1b, 0xae, 0xb5, 0x54, 0x5d,
0x40, 0xfb, 0x78, 0xd8, 0x0d, 0x82, 0x9f, 0xd3, 0xe8, 0x3b, 0xb5, 0x9f, 0xcb, 0xb9, 0x98, 0xf0,
0xeb, 0x7c, 0xf8, 0x51, 0x5b, 0x11, 0x44, 0xda, 0xf6, 0xbd, 0x10, 0x02, 0x56, 0xdf, 0x46, 0xbf,
0xfc, 0x36, 0xce, 0x32, 0x26, 0xb6, 0x4b, 0x56, 0x07, 0xee, 0xea, 0x28, 0xd1, 0x48, 0xc9, 0xb4,
0xdd, 0x8f, 0x83, 0x0c, 0x18, 0xfe, 0x32, 0xfa, 0xae, 0x92, 0x9c, 0xb0, 0x84, 0x2f, 0x58, 0x39,
0xf4, 0x6a, 0x81, 0x90, 0x78, 0xe4, 0x2d, 0x08, 0xdb, 0xde, 0xe6, 0xf9, 0x82, 0x95, 0xc2, 0x6f,
0x1b, 0x84, 0x61, 0xdb, 0x06, 0x02, 0xdb, 0x7f, 0x3b, 0x88, 0x7e, 0xb0, 0x95, 0x24, 0x7c, 0x9e,
0x8b, 0x03, 0x9e, 0xc4, 0xd9, 0x41, 0x9a, 0x5f, 0x1d, 0xb1, 0xeb, 0xed, 0xcb, 0x9a, 0xcf, 0xa7,
0x6c, 0xf8, 0xdc, 0x7d, 0xaa, 0x0a, 0x1d, 0x69, 0x76, 0x64, 0xc3, 0xda, 0xf7, 0xa7, 0xcb, 0x29,
0x41, 0x2c, 0xff, 0x38, 0x88, 0x56, 0x70, 0x2c, 0x63, 0x9e, 0x2d, 0x98, 0x89, 0xe6, 0xb3, 0x0e,
0xc3, 0x2e, 0xae, 0xe3, 0x79, 0xb1, 0xac, 0x1a, 0x44, 0x94, 0x45, 0xdf, 0xb3, 0xd3, 0x65, 0xcc,
0x2a, 0x39, 0x9c, 0x1e, 0xd1, 0x19, 0x01, 0x88, 0xf6, 0xfc, 0xb8, 0x0f, 0x0a, 0xde, 0xd2, 0x68,
0x08, 0xde, 0x32, 0x5e, 0x69, 0x67, 0x0f, 0xbd, 0x16, 0x2c, 0x42, 0xfb, 0x7a, 0xd4, 0x83, 0x04,
0x57, 0x7f, 0x18, 0xfd, 0xca, 0x5b, 0x5e, 0x5e, 0x55, 0x45, 0x9c, 0x30, 0x18, 0x0a, 0x0f, 0x5c,
0xed, 0x46, 0x8a, 0x47, 0xc3, 0x6a, 0x17, 0x66, 0x25, 0x6d, 0x23, 0x7c, 0x5d, 0x30, 0x3c, 0x07,
0x19, 0xc5, 0x5a, 0x48, 0x25, 0x2d, 0x86, 0xc0, 0xf6, 0x55, 0x34, 0x34, 0xb6, 0xcf, 0xff, 0x88,
0x25, 0x62, 0x6b, 0x32, 0xc1, 0xbd, 0x62, 0x74, 0x25, 0x31, 0xda, 0x9a, 0x4c, 0xa8, 0x5e, 0xf1,
0xa3, 0xe0, 0xec, 0x3a, 0x7a, 0x1f, 0x39, 0x3b, 0x48, 0x2b, 0xe9, 0x70, 0x23, 0x6c, 0x05, 0x30,
0xed, 0x74, 0xd4, 0x17, 0x07, 0xc7, 0x7f, 0x3e, 0x88, 0xbe, 0xef, 0xf1, 0x7c, 0xc2, 0x66, 0x7c,
0xc1, 0x86, 0x4f, 0xbb, 0xad, 0x29, 0x52, 0xfb, 0xff, 0x64, 0x09, 0x0d, 0x4f, 0x9a, 0x8c, 0x59,
0xc6, 0x12, 0x41, 0xa6, 0x89, 0x12, 0x77, 0xa6, 0x89, 0xc6, 0xac, 0x11, 0xd6, 0x08, 0xf7, 0x98,
0xd8, 0x9e, 0x97, 0x25, 0xcb, 0x05, 0xd9, 0x97, 0x06, 0xe9, 0xec, 0x4b, 0x07, 0xf5, 0xb4, 0x67,
0x8f, 0x89, 0xad, 0x2c, 0x23, 0xdb, 0xa3, 0xc4, 0x9d, 0xed, 0xd1, 0x18, 0x78, 0x48, 0xa2, 0x5f,
0xb5, 0x9e, 0x98, 0xd8, 0xcf, 0x2f, 0xf8, 0x90, 0x7e, 0x16, 0x52, 0xae, 0x7d, 0xac, 0x75, 0x72,
0x9e, 0x66, 0xbc, 0xba, 0x29, 0x78, 0x49, 0x77, 0x8b, 0x12, 0x77, 0x36, 0x43, 0x63, 0xe0, 0xe1,
0x0f, 0xa2, 0xf7, 0x60, 0x96, 0x6c, 0xd6, 0xb3, 0xfb, 0xde, 0x29, 0x14, 0x2f, 0x68, 0x0f, 0x3a,
0x28, 0x33, 0x39, 0x80, 0x0c, 0x26, 0x9f, 0x8f, 0xbd, 0x7a, 0x68, 0xea, 0xb9, 0x1f, 0x86, 0x5a,
0xb6, 0x77, 0x58, 0xc6, 0x48, 0xdb, 0x4a, 0xd8, 0x61, 0x5b, 0x43, 0x60, 0xbb, 0x8c, 0x7e, 0x43,
0x3f, 0x96, 0x7a, 0x1d, 0x95, 0xf2, 0x7a, 0x92, 0x5e, 0x27, 0xda, 0x6d, 0x43, 0xda, 0xd7, 0x93,
0x7e, 0x70, 0xab, 0x3d, 0x30, 0x02, 0xfd, 0xed, 0x41, 0xe3, 0xef, 0x7e, 0x18, 0x02, 0xdb, 0x7f,
0x37, 0x88, 0x7e, 0x08, 0xb2, 0x57, 0x79, 0x7c, 0x9e, 0x31, 0xb9, 0x24, 0x1e, 0x31, 0x71, 0xcd,
0xcb, 0xab, 0xf1, 0x6d, 0x9e, 0x10, 0xcb, 0xbf, 0x1f, 0xee, 0x58, 0xfe, 0x49, 0x25, 0xab, 0xe2,
0x83, 0x86, 0x0a, 0x5e, 0xe0, 0x8a, 0xaf, 0x69, 0x81, 0xe0, 0x05, 0x55, 0xf1, 0xb9, 0x48, 0xcb,
0xea, 0x61, 0x3d, 0x6d, 0xfa, 0xad, 0x1e, 0xda, 0xf3, 0xe4, 0xbd, 0x10, 0x62, 0xa6, 0xad, 0x26,
0x81, 0x79, 0x7e, 0x91, 0x4e, 0xcf, 0x8a, 0x49, 0x9d, 0xc6, 0x8f, 0xfc, 0x19, 0x6a, 0x21, 0xc4,
0xb4, 0x45, 0xa0, 0xe0, 0xed, 0x1f, 0x4c, 0x61, 0x04, 0x43, 0x69, 0xb7, 0xe4, 0xb3, 0x03, 0x36,
0x8d, 0x93, 0x5b, 0x18, 0xff, 0x9f, 0x86, 0x06, 0x1e, 0xa6, 0x75, 0x10, 0x9f, 0x2d, 0xa9, 0x05,
0xf1, 0xfc, 0xe7, 0x20, 0xba, 0xdf, 0x34, 0xff, 0x32, 0xce, 0xa7, 0x0c, 0xfa, 0x53, 0x45, 0xbf,
0x95, 0x4f, 0x4e, 0x58, 0x25, 0xe2, 0x52, 0x0c, 0x7f, 0xec, 0x6f, 0x64, 0x48, 0x47, 0xc7, 0xf6,
0x93, 0x6f, 0xa5, 0x6b, 0x7a, 0x7d, 0x5c, 0x4f, 0x6c, 0x30, 0x05, 0xb8, 0xbd, 0x2e, 0x25, 0x78,
0x02, 0xb8, 0x17, 0x42, 0x4c, 0xaf, 0x4b, 0xc1, 0x7e, 0xbe, 0x48, 0x05, 0xdb, 0x63, 0x39, 0x2b,
0xdb, 0xbd, 0xae, 0x54, 0x5d, 0x84, 0xe8, 0x75, 0x02, 0x35, 0x93, 0x8d, 0xe3, 0x4d, 0x2f, 0x8e,
0xeb, 0x01, 0x23, 0xad, 0xe5, 0xf1, 0x49, 0x3f, 0xd8, 0xec, 0xee, 0x2c, 0x9f, 0x27, 0x6c, 0xc1,
0xaf, 0xf0, 0xee, 0xce, 0x36, 0xa1, 0x00, 0x62, 0x77, 0xe7, 0x05, 0xcd, 0x0a, 0x66, 0xf9, 0x79,
0x93, 0xb2, 0x6b, 0xb4, 0x82, 0xd9, 0xca, 0xb5, 0x98, 0x58, 0xc1, 0x3c, 0x18, 0x78, 0x38, 0x8a,
0x7e, 0x49, 0x0a, 0x7f, 0x8f, 0xa7, 0xf9, 0xf0, 0xae, 0x47, 0xa9, 0x16, 0x68, 0xab, 0x1f, 0xd2,
0x00, 0x8a, 0xb8, 0xfe, 0xeb, 0x76, 0x9c, 0x27, 0x2c, 0xf3, 0x46, 0x6c, 0xc4, 0xc1, 0x88, 0x1d,
0x0c, 0x45, 0xfc, 0xea, 0x26, 0x15, 0xde, 0x88, 0x6b, 0x41, 0x30, 0x62, 0x00, 0x50, 0xb6, 0x82,
0xc6, 0x56, 0x51, 0x94, 0xf5, 0x0c, 0xe8, 0xcb, 0x56, 0x17, 0x09, 0x66, 0x6b, 0x0b, 0xf5, 0x7b,
0xdb, 0x61, 0x49, 0x96, 0xe6, 0x41, 0x6f, 0x80, 0xf4, 0xf1, 0x66, 0x50, 0xf0, 0x36, 0x8f, 0xde,
0x97, 0xc0, 0x71, 0x5c, 0x8a, 0x34, 0x49, 0x8b, 0x38, 0x6f, 0xea, 0x62, 0x5f, 0xbe, 0xb7, 0x28,
0xed, 0x73, 0xa3, 0x27, 0x0d, 0x6e, 0xff, 0x7d, 0x10, 0x7d, 0x84, 0xfd, 0x1e, 0xb3, 0x72, 0x96,
0xca, 0xed, 0x55, 0xa5, 0x26, 0xa7, 0xe1, 0xe7, 0x61, 0xa3, 0x2d, 0x05, 0x1d, 0xcd, 0x8f, 0x96,
0x57, 0x84, 0xc0, 0x7e, 0x3f, 0x8a, 0x54, 0x19, 0x2f, 0xb7, 0x5a, 0x6e, 0x6e, 0x40, 0x7d, 0xef,
0xec, 0xb3, 0x3e, 0x0a, 0x10, 0x66, 0x0a, 0x55, 0x7f, 0x97, 0x3b, 0xc8, 0xa1, 0x57, 0x43, 0x8a,
0x88, 0x29, 0x14, 0x21, 0x38, 0xd0, 0xf1, 0x25, 0xbf, 0xf6, 0x07, 0x5a, 0x4b, 0xc2, 0x81, 0x02,
0x61, 0xce, 0x74, 0x20, 0x50, 0xdf, 0x99, 0x4e, 0x13, 0x46, 0xe8, 0x4c, 0x07, 0x33, 0x60, 0x98,
0x47, 0xbf, 0x6e, 0x1b, 0x7e, 0xc9, 0xf9, 0xd5, 0x2c, 0x2e, 0xaf, 0x86, 0x8f, 0x69, 0xe5, 0x86,
0xd1, 0x8e, 0xd6, 0x7b, 0xb1, 0x66, 0x0c, 0xd9, 0x0e, 0xeb, 0x05, 0xf8, 0xac, 0xcc, 0xd0, 0x18,
0x72, 0x6c, 0x00, 0x42, 0x8c, 0x21, 0x02, 0x35, 0x33, 0x9a, 0xed, 0x6d, 0xcc, 0xf0, 0x2e, 0xc2,
0x51, 0x1f, 0x33, 0x6a, 0x17, 0xe1, 0xc1, 0x70, 0x0a, 0xed, 0x95, 0x71, 0x71, 0xe9, 0x4f, 0x21,
0x29, 0x0a, 0xa7, 0x50, 0x83, 0xe0, 0xfe, 0x1e, 0xb3, 0xb8, 0x4c, 0x2e, 0xfd, 0xfd, 0xad, 0x64,
0xe1, 0xfe, 0xd6, 0x8c, 0x59, 0x70, 0x6d, 0xc3, 0xe3, 0xf9, 0x79, 0x95, 0x94, 0xe9, 0x39, 0x1b,
0xae, 0xd3, 0xda, 0x1a, 0x22, 0x16, 0x5c, 0x12, 0x36, 0x67, 0x3e, 0xe0, 0xb3, 0x91, 0xed, 0x4f,
0x2a, 0x74, 0xe6, 0xd3, 0xd8, 0xb0, 0x08, 0xe2, 0xcc, 0xc7, 0x4f, 0xe2, 0xe6, 0xed, 0x95, 0x7c,
0x5e, 0x54, 0x1d, 0xcd, 0x43, 0x50, 0xb8, 0x79, 0x6d, 0x18, 0x7c, 0xde, 0x44, 0xbf, 0x69, 0x3f,
0xd2, 0xb3, 0xbc, 0xd2, 0x5e, 0x37, 0xe8, 0xe7, 0x64, 0x61, 0xc4, 0xe9, 0x49, 0x00, 0x37, 0x1b,
0xf1, 0xc6, 0xb3, 0xd8, 0x61, 0x22, 0x4e, 0xb3, 0x6a, 0xb8, 0xea, 0xb7, 0xd1, 0xc8, 0x89, 0x8d,
0xb8, 0x8f, 0xc3, 0x43, 0x68, 0x67, 0x5e, 0x64, 0x69, 0xd2, 0x3e, 0x46, 0x03, 0x5d, 0x2d, 0x0e,
0x0f, 0x21, 0x1b, 0xc3, 0x53, 0xc2, 0x98, 0x09, 0xf5, 0x1f, 0xa7, 0xb7, 0x05, 0xf3, 0x4f, 0x09,
0x0e, 0x12, 0x9e, 0x12, 0x30, 0x8a, 0xdb, 0x33, 0x66, 0xe2, 0x20, 0xbe, 0xe5, 0x73, 0x62, 0x4a,
0xd0, 0xe2, 0x70, 0x7b, 0x6c, 0xcc, 0x2c, 0xdc, 0xda, 0xc3, 0x7e, 0x2e, 0x58, 0x99, 0xc7, 0xd9,
0x6e, 0x16, 0x4f, 0xab, 0x21, 0x31, 0x6e, 0x5c, 0x8a, 0x58, 0xb8, 0x69, 0xda, 0xf3, 0x18, 0xf7,
0xab, 0xdd, 0x78, 0xc1, 0xcb, 0x54, 0xd0, 0x8f, 0xd1, 0x20, 0x9d, 0x8f, 0xd1, 0x41, 0xbd, 0xde,
0xb6, 0xca, 0xe4, 0x32, 0x5d, 0xb0, 0x49, 0xc0, 0x5b, 0x83, 0xf4, 0xf0, 0x66, 0xa1, 0x9e, 0x4e,
0x1b, 0xf3, 0x79, 0x99, 0x30, 0xb2, 0xd3, 0x94, 0xb8, 0xb3, 0xd3, 0x34, 0x06, 0x1e, 0xfe, 0x6a,
0x10, 0xfd, 0x96, 0x92, 0xda, 0x67, 0x5b, 0x3b, 0x71, 0x75, 0x79, 0xce, 0xe3, 0x72, 0x32, 0xfc,
0xc4, 0x67, 0xc7, 0x8b, 0x6a, 0xd7, 0xcf, 0x96, 0x51, 0xc1, 0x8f, 0xf5, 0x20, 0xad, 0xac, 0x11,
0xe7, 0x7d, 0xac, 0x0e, 0x12, 0x7e, 0xac, 0x18, 0xc5, 0x13, 0x88, 0x94, 0xab, 0x7d, 0xe4, 0x2a,
0xa9, 0xef, 0x6e, 0x26, 0xd7, 0x3a, 0x39, 0x3c, 0x3f, 0xd6, 0x42, 0x37, 0x5b, 0x36, 0x28, 0x1b,
0xfe, 0x8c, 0x19, 0xf5, 0xc5, 0x49, 0xcf, 0x7a, 0x54, 0x84, 0x3d, 0xb7, 0x46, 0xc6, 0xa8, 0x2f,
0x4e, 0x78, 0xb6, 0xa6, 0xb5, 0x90, 0x67, 0xcf, 0xd4, 0x36, 0xea, 0x8b, 0xe3, 0x04, 0xda, 0x2a,
0x8a, 0xec, 0xf6, 0x94, 0xcd, 0x8a, 0x8c, 0x4c, 0x20, 0x07, 0x09, 0x27, 0x10, 0x46, 0x71, 0xf5,
0x73, 0xca, 0xeb, 0xda, 0xca, 0x5b, 0xfd, 0x48, 0x51, 0xb8, 0xfa, 0x69, 0x10, 0x5c, 0x30, 0x9c,
0xf2, 0x6d, 0x9e, 0x65, 0x2c, 0x11, 0xed, 0x4b, 0x22, 0xad, 0x69, 0x88, 0x70, 0xc1, 0x80, 0x48,
0x73, 0x18, 0xd0, 0xd4, 0xea, 0x71, 0xc9, 0x5e, 0xde, 0x1e, 0xa4, 0xf9, 0xd5, 0xd0, 0xbf, 0x36,
0x1a, 0x80, 0x38, 0x0c, 0xf0, 0x82, 0x78, 0x4f, 0x70, 0x96, 0x4f, 0xb8, 0x7f, 0x4f, 0x50, 0x4b,
0xc2, 0x7b, 0x02, 0x20, 0xb0, 0xc9, 0x13, 0x46, 0x99, 0xac, 0x25, 0x61, 0x93, 0x40, 0xf8, 0xe6,
0x03, 0x38, 0x75, 0x23, 0xe7, 0x03, 0x74, 0xce, 0xb6, 0xd6, 0xc9, 0xe1, 0x0c, 0x6d, 0x36, 0x07,
0xbb, 0x4c, 0x24, 0x97, 0xfe, 0x0c, 0x75, 0x90, 0x70, 0x86, 0x62, 0x14, 0x37, 0xe9, 0x94, 0xeb,
0xcd, 0xcd, 0xaa, 0x3f, 0x3f, 0x5a, 0x1b, 0x9b, 0xb5, 0x4e, 0x0e, 0x97, 0xeb, 0xfb, 0x33, 0xf9,
0xcc, 0xbc, 0x49, 0xae, 0x64, 0xe1, 0x72, 0x5d, 0x33, 0x38, 0x7a, 0x25, 0xa8, 0x1f, 0xa7, 0x3f,
0x7a, 0x23, 0x0f, 0x47, 0xef, 0x70, 0xe0, 0xe4, 0x5f, 0x07, 0xd1, 0x5d, 0xdb, 0xcb, 0x11, 0xaf,
0xc7, 0xc8, 0x9b, 0x38, 0x4b, 0x27, 0xb1, 0x60, 0xa7, 0xfc, 0x8a, 0xe5, 0x68, 0xbf, 0xef, 0x46,
0xab, 0xf8, 0x91, 0xa3, 0x40, 0xec, 0xf7, 0x7b, 0x29, 0xe2, 0x3c, 0x51, 0xf4, 0x59, 0xc5, 0xb6,
0xe3, 0x8a, 0x98, 0xc9, 0x1c, 0x24, 0x9c, 0x27, 0x18, 0xc5, 0x45, 0x9b, 0x92, 0xbf, 0xba, 0x29,
0x58, 0x99, 0xb2, 0x3c, 0x61, 0xfe, 0xa2, 0x0d, 0x53, 0xe1, 0xa2, 0xcd, 0x43, 0xb7, 0xb6, 0xc3,
0x7a, 0x72, 0x6a, 0xdf, 0xf3, 0x62, 0x22, 0x70, 0xcf, 0x4b, 0xa0, 0xb8, 0x91, 0x06, 0xf0, 0x1e,
0x29, 0xb5, 0xac, 0x04, 0x8f, 0x94, 0x68, 0xba, 0x75, 0xc8, 0xa0, 0x99, 0x71, 0x3d, 0x4c, 0x3a,
0x42, 0x1f, 0xdb, 0xc3, 0x65, 0xbd, 0x17, 0xeb, 0x3f, 0xd5, 0x38, 0x61, 0x59, 0x2c, 0x97, 0x90,
0xc0, 0xd1, 0x41, 0xc3, 0xf4, 0x39, 0xd5, 0xb0, 0x58, 0x70, 0xf8, 0x17, 0x83, 0xe8, 0x8e, 0xcf,
0xe3, 0xeb, 0x42, 0xfa, 0x7d, 0xda, 0x6d, 0x4b, 0x91, 0xc4, 0x45, 0x76, 0x58, 0x03, 0x62, 0xf8,
0x93, 0xe8, 0x83, 0x46, 0x64, 0xee, 0xb9, 0x21, 0x00, 0xb7, 0x8a, 0xd0, 0xf1, 0x63, 0x4e, 0xbb,
0xdf, 0xec, 0xcd, 0x9b, 0x02, 0xdd, 0x8d, 0xab, 0x42, 0x05, 0xba, 0xb6, 0x01, 0x62, 0xa2, 0x40,
0xf7, 0x60, 0x78, 0xa5, 0x6e, 0x90, 0x7a, 0x9c, 0xf8, 0xe6, 0x38, 0x6d, 0xc2, 0x1e, 0x25, 0x0f,
0xbb, 0x41, 0x9c, 0x3b, 0x8d, 0x18, 0xea, 0xe2, 0xc7, 0x21, 0x0b, 0xa8, 0x36, 0x5e, 0xef, 0xc5,
0x82, 0xc3, 0x3f, 0x8b, 0xbe, 0xdf, 0x6a, 0xd8, 0x2e, 0x8b, 0xc5, 0xbc, 0x64, 0x93, 0xe1, 0x66,
0x47, 0xdc, 0x0d, 0xa8, 0x5d, 0x3f, 0xed, 0xaf, 0x00, 0xfe, 0xff, 0x66, 0x10, 0xfd, 0xc0, 0xe5,
0x54, 0x17, 0xeb, 0x18, 0x9e, 0x85, 0x4c, 0xba, 0xac, 0x0e, 0xe3, 0xf9, 0x52, 0x3a, 0xad, 0x3d,
0x98, 0x9d, 0xc8, 0x5b, 0x8b, 0x38, 0xcd, 0xe2, 0xf3, 0x8c, 0x79, 0xf7, 0x60, 0x4e, 0x6e, 0x6a,
0x34, 0xb8, 0x07, 0x23, 0x55, 0x5a, 0xb3, 0xa4, 0x1c, 0x6f, 0x56, 0xed, 0xfe, 0x84, 0x1e, 0x95,
0x9e, 0xd2, 0x7d, 0xa3, 0x27, 0x0d, 0x6e, 0x45, 0x73, 0x76, 0x55, 0xff, 0xd9, 0x4e, 0x72, 0x9f,
0x57, 0x50, 0xf5, 0x64, 0xfa, 0x46, 0x4f, 0x1a, 0xbc, 0xfe, 0x69, 0xf4, 0x41, 0xdb, 0x2b, 0x2c,
0x0a, 0x9b, 0x9d, 0xa6, 0xd0, 0xba, 0xf0, 0xb4, 0xbf, 0x82, 0x29, 0xf5, 0xbf, 0x48, 0x2b, 0xc1,
0xcb, 0xdb, 0xf1, 0x25, 0xbf, 0x6e, 0xde, 0xe5, 0x74, 0x47, 0x2b, 0x00, 0x23, 0x8b, 0x20, 0x4a,
0x7d, 0x3f, 0xd9, 0x72, 0x65, 0xde, 0xf9, 0xac, 0x08, 0x57, 0x16, 0xd1, 0xe1, 0xca, 0x25, 0xcd,
0x5c, 0xd5, 0xb4, 0xca, 0xbc, 0xa0, 0xba, 0xe6, 0x0f, 0xb5, 0xfd, 0x92, 0xea, 0xc3, 0x6e, 0xd0,
0x6c, 0xbf, 0x76, 0xd3, 0x8c, 0xbd, 0xbe, 0xb8, 0xc8, 0x78, 0x3c, 0x41, 0xdb, 0xaf, 0x5a, 0x32,
0x02, 0x11, 0xb1, 0xfd, 0x42, 0x88, 0x29, 0x3a, 0x6b, 0x81, 0xbc, 0x9b, 0x69, 0x4c, 0xaf, 0xb6,
0xf5, 0x6c, 0x39, 0x51, 0x74, 0xfa, 0x38, 0xb3, 0x60, 0xd4, 0xd2, 0x7a, 0x08, 0x36, 0x3e, 0x1e,
0xb4, 0x75, 0x2d, 0x31, 0xb1, 0x60, 0x78, 0x30, 0xb3, 0x3f, 0xaa, 0x85, 0x67, 0x85, 0x34, 0xfe,
0x61, 0x5b, 0x4b, 0x49, 0x88, 0xfd, 0x91, 0x4b, 0x98, 0x3a, 0xbf, 0xfe, 0xfb, 0x0e, 0xbf, 0xce,
0xa5, 0x51, 0xcf, 0xd3, 0x6c, 0x64, 0x44, 0x9d, 0x8f, 0x19, 0x30, 0xfc, 0xd3, 0xe8, 0x17, 0xa5,
0xe1, 0x92, 0x17, 0xc3, 0x15, 0x8f, 0x42, 0x69, 0xbd, 0x11, 0x72, 0x97, 0x94, 0x9b, 0x17, 0x9b,
0x74, 0xff, 0x9d, 0x55, 0xf1, 0x94, 0xa1, 0x17, 0x9b, 0x4c, 0xaf, 0x48, 0x29, 0xf1, 0x62, 0x53,
0x9b, 0x32, 0x2f, 0xeb, 0xd4, 0xb2, 0x23, 0x3e, 0x01, 0xeb, 0x9e, 0x16, 0x6a, 0x21, 0xf1, 0xb2,
0x4e, 0x0b, 0x32, 0xe7, 0xf7, 0x47, 0xf1, 0x22, 0x9d, 0xea, 0xc9, 0x5f, 0xcd, 0x21, 0x15, 0x3a,
0xbf, 0x37, 0xcc, 0xc8, 0x82, 0x88, 0xf3, 0x7b, 0x12, 0x06, 0x9f, 0xff, 0x32, 0x88, 0x3e, 0x34,
0xcc, 0x5e, 0x73, 0xac, 0xb2, 0x9f, 0x5f, 0xf0, 0xb7, 0xa9, 0xb8, 0xac, 0xf7, 0xf1, 0xd5, 0xf0,
0x05, 0x65, 0xd2, 0xcf, 0xeb, 0x50, 0x3e, 0x5f, 0x5a, 0xcf, 0x54, 0x73, 0xcd, 0x71, 0x8b, 0xb9,
0xdb, 0x52, 0x1a, 0xa8, 0x9a, 0xd3, 0xa7, 0x32, 0x98, 0x23, 0xaa, 0xb9, 0x10, 0x6f, 0xba, 0x58,
0x3b, 0xcf, 0x78, 0x8e, 0xbb, 0xd8, 0x58, 0xa8, 0x85, 0x44, 0x17, 0xb7, 0x20, 0x33, 0x37, 0x36,
0x22, 0x75, 0x32, 0xb0, 0x95, 0x65, 0x68, 0x6e, 0xd4, 0xaa, 0x1a, 0x20, 0xe6, 0x46, 0x2f, 0x08,
0x7e, 0x4e, 0xa2, 0xef, 0xd4, 0x8f, 0xf4, 0xb8, 0x64, 0x8b, 0x94, 0xe1, 0x6b, 0x58, 0x4b, 0x42,
0x8c, 0x7f, 0x97, 0x30, 0x23, 0xeb, 0x2c, 0xaf, 0x8a, 0x2c, 0xae, 0x2e, 0xe1, 0x62, 0xce, 0x6d,
0x73, 0x23, 0xc4, 0x57, 0x73, 0x0f, 0x3a, 0x28, 0x33, 0xf1, 0x36, 0x32, 0x3d, 0xc5, 0xac, 0xfa,
0x55, 0x5b, 0xd3, 0xcc, 0x5a, 0x27, 0x67, 0x8e, 0x26, 0xf7, 0xe2, 0x2c, 0x63, 0xe5, 0x6d, 0x23,
0x3b, 0x8c, 0xf3, 0xf4, 0x82, 0x55, 0x02, 0x1d, 0x4d, 0x02, 0x35, 0xc2, 0x18, 0x71, 0x34, 0x19,
0xc0, 0x4d, 0x65, 0x8d, 0x3c, 0xef, 0xe7, 0x13, 0x76, 0x83, 0x2a, 0x6b, 0x6c, 0x47, 0x32, 0x44,
0x65, 0x4d, 0xb1, 0x66, 0x79, 0x7c, 0x99, 0xf1, 0xe4, 0x0a, 0x96, 0x00, 0xb7, 0x83, 0xa5, 0x04,
0xaf, 0x01, 0xf7, 0x42, 0x88, 0x59, 0x04, 0xa4, 0xe0, 0x84, 0x15, 0x59, 0x9c, 0xe0, 0xbb, 0x78,
0xa5, 0x03, 0x32, 0x62, 0x11, 0xc0, 0x0c, 0x0a, 0x17, 0xee, 0xf8, 0x7d, 0xe1, 0xa2, 0x2b, 0xfe,
0x7b, 0x21, 0xc4, 0x2c, 0x83, 0x52, 0x30, 0x2e, 0xb2, 0x54, 0xa0, 0x61, 0xa0, 0x34, 0xa4, 0x84,
0x18, 0x06, 0x2e, 0x81, 0x4c, 0x1e, 0xb2, 0x72, 0xca, 0xbc, 0x26, 0xa5, 0x24, 0x68, 0xb2, 0x21,
0xcc, 0x8b, 0x41, 0xaa, 0xed, 0xbc, 0xb8, 0x45, 0x2f, 0x06, 0x41, 0xb3, 0x78, 0x71, 0x4b, 0xbc,
0x18, 0xe4, 0x00, 0x28, 0xc4, 0xe3, 0xb8, 0x12, 0xfe, 0x10, 0xa5, 0x24, 0x18, 0x62, 0x43, 0x98,
0x35, 0x5a, 0x85, 0x38, 0x17, 0x68, 0x8d, 0x86, 0x00, 0xac, 0xab, 0xc2, 0xbb, 0xa4, 0xdc, 0xcc,
0x24, 0xaa, 0x57, 0x98, 0xd8, 0x4d, 0x59, 0x36, 0xa9, 0xd0, 0x4c, 0x02, 0xcf, 0xbd, 0x91, 0x12,
0x33, 0x49, 0x9b, 0x42, 0xa9, 0x04, 0x67, 0xb8, 0xbe, 0xd6, 0xa1, 0xe3, 0xdb, 0x7b, 0x21, 0xc4,
0xcc, 0x4f, 0x4d, 0xd0, 0xdb, 0x71, 0x59, 0xa6, 0xf5, 0xe2, 0xbf, 0xea, 0x0f, 0xa8, 0x91, 0x13,
0xf3, 0x93, 0x8f, 0x43, 0xc3, 0xab, 0x99, 0xb8, 0x7d, 0x81, 0xe1, 0xa9, 0xfb, 0xe3, 0x20, 0x63,
0x2a, 0x4e, 0x29, 0xb1, 0xee, 0xba, 0x7c, 0x4f, 0xd3, 0x73, 0xd5, 0xb5, 0xda, 0x85, 0x59, 0xaf,
0x1a, 0x6b, 0x17, 0x87, 0x7c, 0xc1, 0x4e, 0xf9, 0xab, 0x9b, 0xb4, 0x12, 0x69, 0x3e, 0x85, 0x95,
0xfb, 0x39, 0x61, 0xc9, 0x07, 0x13, 0xaf, 0x1a, 0x77, 0x2a, 0x99, 0x02, 0x02, 0xc5, 0x72, 0xc4,
0xae, 0xbd, 0x05, 0x04, 0xb6, 0xa8, 0x39, 0xa2, 0x80, 0x08, 0xf1, 0xe6, 0x4c, 0x43, 0x3b, 0x87,
0xdf, 0x63, 0x9d, 0xf2, 0xa6, 0x96, 0xa3, 0xac, 0x61, 0x90, 0xd8, 0x56, 0x06, 0x15, 0xcc, 0x5e,
0x4f, 0xfb, 0x37, 0x43, 0xec, 0x21, 0x61, 0xa7, 0x3d, 0xcc, 0x1e, 0xf5, 0x20, 0x3d, 0xae, 0xcc,
0x85, 0x2d, 0xe5, 0xaa, 0x7d, 0x5f, 0xfb, 0xa8, 0x07, 0x69, 0x9d, 0x8f, 0xd8, 0xcd, 0x7a, 0x19,
0x27, 0x57, 0xd3, 0x92, 0xcf, 0xf3, 0xc9, 0x36, 0xcf, 0x78, 0x89, 0xce, 0x47, 0x9c, 0xa8, 0x11,
0x4a, 0x9c, 0x8f, 0x74, 0xa8, 0x98, 0x0a, 0xce, 0x8e, 0x62, 0x2b, 0x4b, 0xa7, 0x78, 0x77, 0xeb,
0x18, 0x92, 0x00, 0x51, 0xc1, 0x79, 0x41, 0x4f, 0x12, 0xa9, 0xdd, 0xaf, 0x48, 0x93, 0x38, 0x53,
0xfe, 0x36, 0x69, 0x33, 0x0e, 0xd8, 0x99, 0x44, 0x1e, 0x05, 0x4f, 0x3b, 0x4f, 0xe7, 0x65, 0xbe,
0x9f, 0x0b, 0x4e, 0xb6, 0xb3, 0x01, 0x3a, 0xdb, 0x69, 0x81, 0x68, 0x5a, 0x3d, 0x65, 0x37, 0x75,
0x34, 0xf5, 0x3f, 0xbe, 0x69, 0xb5, 0xfe, 0xfb, 0x08, 0xe4, 0xa1, 0x69, 0x15, 0x71, 0xa8, 0x31,
0xe0, 0x44, 0x25, 0x4c, 0x40, 0xdb, 0x4d, 0x93, 0x87, 0xdd, 0xa0, 0xdf, 0xcf, 0x58, 0xdc, 0x66,
0x2c, 0xe4, 0x47, 0x02, 0x7d, 0xfc, 0x34, 0xa0, 0xb9, 0x38, 0x71, 0xda, 0x73, 0xc9, 0x92, 0xab,
0xd6, 0xfb, 0x27, 0x6e, 0xa0, 0x0a, 0x21, 0x2e, 0x4e, 0x08, 0xd4, 0xdf, 0x45, 0xfb, 0x09, 0xcf,
0x43, 0x5d, 0x54, 0xcb, 0xfb, 0x74, 0x11, 0x70, 0x66, 0xf3, 0xab, 0xa5, 0x90, 0x99, 0xaa, 0x9b,
0xd6, 0x09, 0x0b, 0x36, 0x44, 0x6c, 0x7e, 0x49, 0xd8, 0xd4, 0xe4, 0xd8, 0xe7, 0x61, 0xfb, 0xfd,
0xcf, 0x96, 0x95, 0x43, 0xfa, 0xfd, 0x4f, 0x8a, 0xa5, 0x1b, 0xa9, 0x72, 0xa4, 0xc3, 0x8a, 0x9b,
0x27, 0x4f, 0xfa, 0xc1, 0x66, 0xcb, 0xe3, 0xf8, 0xdc, 0xce, 0x58, 0x5c, 0x2a, 0xaf, 0x1b, 0x01,
0x43, 0x06, 0x23, 0xb6, 0x3c, 0x01, 0x1c, 0x4d, 0x61, 0x8e, 0xe7, 0x6d, 0x9e, 0x0b, 0x96, 0x0b,
0xdf, 0x14, 0xe6, 0x1a, 0x03, 0x30, 0x34, 0x85, 0x51, 0x0a, 0x28, 0x6f, 0xe5, 0x79, 0x10, 0x13,
0x47, 0xf1, 0xcc, 0x5b, 0xb1, 0xa9, 0xb3, 0x1e, 0x25, 0x0f, 0xe5, 0x2d, 0xe2, 0xd0, 0x90, 0xdf,
0x9f, 0xc5, 0x53, 0xed, 0xc5, 0xa3, 0x2d, 0xe5, 0x2d, 0x37, 0x0f, 0xbb, 0x41, 0xe4, 0xe7, 0x4d,
0x3a, 0x61, 0x3c, 0xe0, 0x47, 0xca, 0xfb, 0xf8, 0xc1, 0x20, 0xaa, 0x9c, 0xea, 0xd6, 0xaa, 0xdd,
0xd4, 0x56, 0x3e, 0x81, 0x3d, 0xe4, 0x88, 0x78, 0x28, 0x88, 0x0b, 0x55, 0x4e, 0x04, 0x8f, 0xc6,
0x47, 0x73, 0x38, 0x1a, 0x1a, 0x1f, 0xfa, 0xec, 0xb3, 0xcf, 0xf8, 0xf0, 0xc1, 0xe0, 0xf3, 0x8f,
0x61, 0x7c, 0xec, 0xc4, 0x22, 0xae, 0x6b, 0xe6, 0x37, 0x29, 0xbb, 0x86, 0x4d, 0xa8, 0xa7, 0xbd,
0x0d, 0x35, 0x92, 0x3f, 0x46, 0x41, 0x3b, 0xd2, 0xcd, 0xde, 0x7c, 0xc0, 0x37, 0x54, 0xe7, 0x9d,
0xbe, 0x51, 0x99, 0xbe, 0xd9, 0x9b, 0x0f, 0xf8, 0x86, 0x5f, 0xb9, 0x75, 0xfa, 0x46, 0x3f, 0x75,
0xdb, 0xec, 0xcd, 0x83, 0xef, 0xbf, 0x1c, 0x44, 0x77, 0x5a, 0xce, 0xeb, 0x1a, 0x28, 0x11, 0xe9,
0x82, 0xf9, 0x4a, 0x39, 0xd7, 0x9e, 0x46, 0x43, 0xa5, 0x1c, 0xad, 0x62, 0x7d, 0x1a, 0xc1, 0x17,
0xc5, 0x31, 0xaf, 0x52, 0x79, 0x71, 0xfc, 0xbc, 0x87, 0xd1, 0x06, 0x0e, 0x6d, 0x58, 0x42, 0x4a,
0xe6, 0xda, 0xcd, 0x41, 0xcd, 0xab, 0x9e, 0x4f, 0x02, 0xf6, 0xda, 0x6f, 0x7c, 0x6e, 0xf4, 0xa4,
0xcd, 0x05, 0x98, 0xc3, 0xd8, 0x37, 0x6f, 0xa1, 0x5e, 0xf5, 0x5e, 0xbe, 0x3d, 0xed, 0xaf, 0x00,
0xee, 0xff, 0xba, 0xa9, 0xe9, 0xb1, 0x7f, 0x18, 0x04, 0xcf, 0xfa, 0x58, 0x44, 0x03, 0xe1, 0xf9,
0x52, 0x3a, 0x10, 0xc8, 0x7f, 0x0c, 0xa2, 0x7b, 0xde, 0x40, 0xdc, 0x3b, 0xd8, 0xdf, 0xee, 0x63,
0xdb, 0x7f, 0x17, 0xfb, 0xe3, 0x6f, 0xa3, 0x0a, 0xd1, 0xfd, 0x7d, 0xb3, 0xb5, 0x6e, 0x34, 0xe4,
0xeb, 0xf8, 0xaf, 0xcb, 0x09, 0x2b, 0x61, 0xc4, 0x86, 0x92, 0xce, 0xc0, 0x78, 0xdc, 0x7e, 0xb6,
0xa4, 0x96, 0xf5, 0x19, 0x0f, 0x07, 0x86, 0x5f, 0x26, 0x59, 0xf1, 0x84, 0x2c, 0x5b, 0x34, 0x0e,
0xe8, 0xc5, 0xb2, 0x6a, 0xd4, 0x48, 0xb6, 0x60, 0xf9, 0xab, 0xe0, 0xe7, 0x3d, 0x0d, 0x3b, 0xbf,
0x13, 0xfe, 0x74, 0x39, 0x25, 0x88, 0xe5, 0xbf, 0x06, 0xd1, 0x03, 0x87, 0x35, 0x37, 0x0d, 0xe8,
0x3c, 0xe4, 0x27, 0x01, 0xfb, 0x94, 0x92, 0x0e, 0xee, 0x77, 0xbe, 0x9d, 0xb2, 0xf9, 0xe6, 0x85,
0xa3, 0xb2, 0x9b, 0x66, 0x82, 0x95, 0xed, 0x6f, 0x5e, 0xb8, 0x76, 0x15, 0x35, 0xa2, 0xbf, 0x79,
0x11, 0xc0, 0xad, 0x6f, 0x5e, 0x78, 0x3c, 0x7b, 0xbf, 0x79, 0xe1, 0xb5, 0x16, 0xfc, 0xe6, 0x45,
0x58, 0x83, 0x5a, 0x7c, 0x9a, 0x10, 0xd4, 0x89, 0x76, 0x2f, 0x8b, 0xee, 0x01, 0xf7, 0xb3, 0x65,
0x54, 0x88, 0xe5, 0x57, 0x71, 0xf2, 0xcd, 0xb0, 0x1e, 0xcf, 0xd4, 0x79, 0x3b, 0x6c, 0xb3, 0x37,
0x0f, 0xbe, 0x7f, 0x06, 0xfb, 0x1e, 0xbd, 0xd8, 0xf0, 0x52, 0x7e, 0xef, 0x64, 0x3d, 0xb4, 0x78,
0xd4, 0x16, 0xec, 0x9e, 0x7f, 0xd2, 0x0f, 0x26, 0x9a, 0x5b, 0x13, 0xd0, 0xe9, 0xa3, 0x2e, 0x43,
0xa8, 0xcb, 0x37, 0x7b, 0xf3, 0xc4, 0x22, 0xa7, 0x7c, 0xab, 0xde, 0xee, 0x61, 0xcc, 0xed, 0xeb,
0xa7, 0xfd, 0x15, 0xcc, 0xab, 0x2d, 0x2d, 0xf7, 0xb2, 0x9f, 0x3b, 0x9f, 0xa0, 0xd3, 0xcb, 0x1b,
0x3d, 0xe9, 0x50, 0x71, 0x63, 0x2f, 0xef, 0x5d, 0xc5, 0x8d, 0x77, 0x89, 0xff, 0x74, 0x39, 0x25,
0x88, 0xe5, 0x9f, 0x07, 0xd1, 0x5d, 0x32, 0x16, 0xc8, 0x82, 0x17, 0x7d, 0x2d, 0xa3, 0x6c, 0xf8,
0x7c, 0x69, 0x3d, 0x08, 0xea, 0xdf, 0x06, 0xd1, 0x87, 0x81, 0xa0, 0x54, 0x7a, 0x2c, 0x61, 0xdd,
0x4d, 0x93, 0x1f, 0x2d, 0xaf, 0x48, 0x2d, 0xf6, 0x36, 0x3e, 0x6e, 0x7f, 0x0a, 0x22, 0x60, 0x7b,
0x4c, 0x7f, 0x0a, 0xa2, 0x5b, 0x0b, 0x1f, 0xfe, 0xd4, 0x25, 0x09, 0xec, 0x8b, 0x7c, 0x87, 0x3f,
0xb2, 0x62, 0x41, 0xfb, 0xa1, 0xb5, 0x4e, 0xce, 0xe7, 0xe4, 0xd5, 0x4d, 0x11, 0xe7, 0x13, 0xda,
0x89, 0x92, 0x77, 0x3b, 0xd1, 0x1c, 0x3e, 0x34, 0xab, 0xa5, 0x27, 0xbc, 0xd9, 0xe4, 0x3d, 0xa2,
0xf4, 0x35, 0x12, 0x3c, 0x34, 0x6b, 0xa1, 0x84, 0x37, 0xa8, 0x68, 0x43, 0xde, 0x50, 0x21, 0xfb,
0xb8, 0x0f, 0x8a, 0xb6, 0x0f, 0xda, 0x9b, 0x3e, 0x8b, 0x7f, 0x12, 0xb2, 0xd2, 0x3a, 0x8f, 0xdf,
0xe8, 0x49, 0x13, 0x6e, 0xc7, 0x4c, 0x7c, 0xc1, 0xe2, 0x09, 0x2b, 0x83, 0x6e, 0x35, 0xd5, 0xcb,
0xad, 0x4d, 0xfb, 0xdc, 0x6e, 0xf3, 0x6c, 0x3e, 0xcb, 0xa1, 0x33, 0x49, 0xb7, 0x36, 0xd5, 0xed,
0x16, 0xd1, 0xf8, 0xb8, 0xd0, 0xb8, 0x95, 0xc5, 0xe5, 0xe3, 0xb0, 0x19, 0xa7, 0xa6, 0x5c, 0xef,
0xc5, 0xd2, 0xed, 0x84, 0x34, 0xea, 0x68, 0x27, 0xca, 0xa4, 0x8d, 0x9e, 0x34, 0x3e, 0xb7, 0xb3,
0xdc, 0xea, 0x7c, 0xda, 0xec, 0xb0, 0xd5, 0x4a, 0xa9, 0xa7, 0xfd, 0x15, 0xf0, 0x29, 0x29, 0x64,
0x55, 0xbd, 0x2b, 0xda, 0x4d, 0xb3, 0x6c, 0xb8, 0x1e, 0x48, 0x93, 0x06, 0x0a, 0x9e, 0x92, 0x7a,
0x60, 0x22, 0x93, 0x9b, 0x53, 0xc5, 0x7c, 0xd8, 0x65, 0x47, 0x52, 0xbd, 0x32, 0xd9, 0xa6, 0xd1,
0x69, 0x9b, 0xf5, 0xa8, 0x75, 0x6b, 0x47, 0xe1, 0x07, 0xd7, 0x6a, 0xf0, 0x66, 0x6f, 0x1e, 0x5d,
0xc3, 0x4b, 0x4a, 0xae, 0x2c, 0xf7, 0x29, 0x13, 0xce, 0x4a, 0xf2, 0xa0, 0x83, 0x42, 0x27, 0x96,
0x6a, 0x18, 0xbd, 0x4d, 0x27, 0x53, 0x26, 0xbc, 0x37, 0x48, 0x36, 0x10, 0xbc, 0x41, 0x42, 0x20,
0xea, 0x3a, 0xf5, 0xf7, 0x31, 0x13, 0xa7, 0x71, 0x39, 0x65, 0x62, 0x7f, 0xe2, 0xeb, 0x3a, 0x50,
0xb6, 0xa8, 0x50, 0xd7, 0x79, 0x69, 0x34, 0x1b, 0x68, 0xb7, 0xf0, 0x7b, 0xea, 0xc7, 0x21, 0x33,
0xe8, 0x47, 0xd5, 0xeb, 0xbd, 0x58, 0xb4, 0xa2, 0x18, 0x87, 0xe9, 0x2c, 0x15, 0xbe, 0x15, 0xc5,
0xb2, 0x51, 0x23, 0xa1, 0x15, 0xa5, 0x8d, 0x52, 0xcd, 0xab, 0x6b, 0x84, 0xfd, 0x49, 0xb8, 0x79,
0x8a, 0xe9, 0xd7, 0x3c, 0xcd, 0xb6, 0x2e, 0x3c, 0x73, 0x9d, 0x32, 0xe2, 0x12, 0xb6, 0xca, 0x9e,
0xdc, 0x96, 0x3f, 0x31, 0xc4, 0x60, 0x68, 0xd6, 0xa1, 0x14, 0xac, 0x5f, 0xb1, 0x68, 0xae, 0xb9,
0x93, 0x2d, 0x0a, 0x16, 0x97, 0x71, 0x9e, 0x78, 0xb7, 0xa6, 0xd2, 0x60, 0x8b, 0x0c, 0x6d, 0x4d,
0x49, 0x0d, 0x74, 0x9d, 0xee, 0xfe, 0x38, 0xd0, 0x33, 0x14, 0xf4, 0xaf, 0xf0, 0xdc, 0xdf, 0x06,
0x3e, 0xea, 0x41, 0xe2, 0xeb, 0xf4, 0x06, 0xd0, 0x87, 0xf2, 0xca, 0xe9, 0x27, 0x01, 0x53, 0x2e,
0x1a, 0xda, 0x06, 0xd3, 0x2a, 0x28, 0xa9, 0x75, 0x81, 0xcb, 0xc4, 0x4f, 0xd9, 0xad, 0x2f, 0xa9,
0x4d, 0x7d, 0x2a, 0x91, 0x50, 0x52, 0xb7, 0x51, 0x54, 0x67, 0xda, 0xfb, 0xa0, 0xd5, 0x80, 0xbe,
0xbd, 0xf5, 0x59, 0xeb, 0xe4, 0xd0, 0xc8, 0xd9, 0x49, 0x17, 0xce, 0x1d, 0x86, 0x27, 0xd0, 0x9d,
0x74, 0xe1, 0xbf, 0xc2, 0x58, 0xef, 0xc5, 0xe2, 0xab, 0xfa, 0x58, 0xb0, 0x9b, 0xe6, 0x0e, 0xdd,
0x13, 0xae, 0x94, 0xb7, 0x2e, 0xd1, 0x1f, 0x76, 0x83, 0xe6, 0xc5, 0xd8, 0xe3, 0x92, 0x27, 0xac,
0xaa, 0xe0, 0xfb, 0x58, 0xee, 0x9b, 0x47, 0x20, 0x1b, 0xa1, 0xaf, 0x63, 0xdd, 0x0f, 0x43, 0x60,
0xfb, 0x8b, 0xe8, 0xdd, 0x03, 0x3e, 0x1d, 0xb3, 0x7c, 0x32, 0xfc, 0xa1, 0xfb, 0x2a, 0x2a, 0x9f,
0x8e, 0xea, 0x3f, 0x6b, 0x7b, 0x2b, 0x94, 0xd8, 0xbc, 0x4c, 0xb7, 0xc3, 0xce, 0xe7, 0xd3, 0xd3,
0x92, 0x31, 0xf4, 0x32, 0x9d, 0xfc, 0xfb, 0xa8, 0x16, 0x10, 0x2f, 0xd3, 0x39, 0x80, 0x59, 0x25,
0xb5, 0xbd, 0xba, 0x10, 0xc5, 0x2f, 0xab, 0x19, 0x1d, 0x29, 0x25, 0x56, 0xc9, 0x36, 0x65, 0x3a,
0x4f, 0xca, 0xe4, 0xcb, 0xe6, 0xe3, 0xf9, 0x6c, 0x16, 0x97, 0xb7, 0xa8, 0xf3, 0x94, 0xae, 0x0d,
0x10, 0x9d, 0xe7, 0x05, 0x4d, 0x56, 0x2a, 0x3f, 0x22, 0x4e, 0xae, 0xf6, 0x78, 0xc9, 0xe7, 0x22,
0xcd, 0x59, 0x85, 0xb2, 0x12, 0x2c, 0xb8, 0x0c, 0x91, 0x95, 0x14, 0x6b, 0xaa, 0x38, 0x49, 0xa8,
0xf7, 0xe8, 0xe4, 0x57, 0x21, 0x2b, 0xc1, 0x4b, 0x7c, 0x97, 0xa7, 0xac, 0x60, 0x88, 0xa8, 0xe2,
0x48, 0x18, 0xf5, 0xfd, 0x71, 0x9a, 0x4f, 0xbd, 0x7d, 0x5f, 0x0b, 0x82, 0x7d, 0x0f, 0x80, 0x99,
0x8f, 0xd5, 0x43, 0x53, 0x9f, 0x9f, 0x81, 0xdf, 0xf6, 0x79, 0x1f, 0xba, 0x4d, 0x10, 0xf3, 0xb1,
0x9f, 0x44, 0xae, 0x5e, 0x17, 0x2c, 0x67, 0x93, 0xe6, 0x6d, 0x31, 0x9f, 0x2b, 0x87, 0x08, 0xba,
0xc2, 0xa4, 0x49, 0x85, 0x43, 0x26, 0xca, 0x34, 0xa9, 0xc6, 0x4c, 0x1c, 0xc7, 0x65, 0x3c, 0x63,
0x82, 0x95, 0x38, 0x15, 0x00, 0x19, 0x39, 0x0c, 0x91, 0x0a, 0x14, 0x0b, 0x0e, 0x7f, 0x37, 0xfa,
0x5e, 0x3d, 0x73, 0xb1, 0x1c, 0x3e, 0x53, 0xfd, 0x4a, 0x7e, 0xdf, 0x7e, 0xf8, 0xbe, 0xb6, 0x31,
0x16, 0x25, 0x8b, 0x67, 0x8d, 0xed, 0xf7, 0xf4, 0xdf, 0x25, 0xf8, 0x74, 0x50, 0xcf, 0xdb, 0x47,
0x5c, 0xa4, 0x17, 0xf5, 0x46, 0x01, 0x2e, 0x65, 0xd0, 0xbc, 0x6d, 0x8b, 0x47, 0x81, 0x5f, 0x82,
0xfb, 0x38, 0x33, 0x12, 0x6d, 0xe9, 0x09, 0x2b, 0x32, 0x3c, 0x12, 0x1d, 0x6d, 0x09, 0x10, 0x23,
0xd1, 0x0b, 0x2a, 0x3f, 0x2f, 0x3f, 0xfa, 0x9f, 0xaf, 0x57, 0x06, 0x5f, 0x7d, 0xbd, 0x32, 0xf8,
0xff, 0xaf, 0x57, 0x06, 0xff, 0xf4, 0xcd, 0xca, 0x3b, 0x5f, 0x7d, 0xb3, 0xf2, 0xce, 0xff, 0x7d,
0xb3, 0xf2, 0xce, 0x97, 0xef, 0xc2, 0xff, 0x34, 0xe0, 0xfc, 0x17, 0xe4, 0xa7, 0xff, 0x9f, 0xff,
0x3c, 0x00, 0x00, 0xff, 0xff, 0xbf, 0xc7, 0x5f, 0x26, 0x58, 0x60, 0x00, 0x00,
}
// This is a compile-time assertion to ensure that this generated file
@ -449,7 +450,8 @@ type ClientCommandsHandler interface {
// UnsplashDownload downloads picture from unsplash by ID, put it to the IPFS and returns the hash.
// The artist info is available in the object details
UnsplashDownload(context.Context, *pb.RpcUnsplashDownloadRequest) *pb.RpcUnsplashDownloadResponse
DownloadManifest(context.Context, *pb.RpcDownloadManifestRequest) *pb.RpcDownloadManifestResponse
GalleryDownloadManifest(context.Context, *pb.RpcGalleryDownloadManifestRequest) *pb.RpcGalleryDownloadManifestResponse
GalleryDownloadIndex(context.Context, *pb.RpcGalleryDownloadIndexRequest) *pb.RpcGalleryDownloadIndexResponse
// General Block commands
// ***
BlockUpload(context.Context, *pb.RpcBlockUploadRequest) *pb.RpcBlockUploadResponse
@ -2934,23 +2936,43 @@ func UnsplashDownload(b []byte) (resp []byte) {
return resp
}
func DownloadManifest(b []byte) (resp []byte) {
func GalleryDownloadManifest(b []byte) (resp []byte) {
defer func() {
if PanicHandler != nil {
if r := recover(); r != nil {
resp, _ = (&pb.RpcDownloadManifestResponse{Error: &pb.RpcDownloadManifestResponseError{Code: pb.RpcDownloadManifestResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
resp, _ = (&pb.RpcGalleryDownloadManifestResponse{Error: &pb.RpcGalleryDownloadManifestResponseError{Code: pb.RpcGalleryDownloadManifestResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
PanicHandler(r)
}
}
}()
in := new(pb.RpcDownloadManifestRequest)
in := new(pb.RpcGalleryDownloadManifestRequest)
if err := in.Unmarshal(b); err != nil {
resp, _ = (&pb.RpcDownloadManifestResponse{Error: &pb.RpcDownloadManifestResponseError{Code: pb.RpcDownloadManifestResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
resp, _ = (&pb.RpcGalleryDownloadManifestResponse{Error: &pb.RpcGalleryDownloadManifestResponseError{Code: pb.RpcGalleryDownloadManifestResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
return resp
}
resp, _ = clientCommandsHandler.DownloadManifest(context.Background(), in).Marshal()
resp, _ = clientCommandsHandler.GalleryDownloadManifest(context.Background(), in).Marshal()
return resp
}
func GalleryDownloadIndex(b []byte) (resp []byte) {
defer func() {
if PanicHandler != nil {
if r := recover(); r != nil {
resp, _ = (&pb.RpcGalleryDownloadIndexResponse{Error: &pb.RpcGalleryDownloadIndexResponseError{Code: pb.RpcGalleryDownloadIndexResponseError_UNKNOWN_ERROR, Description: "panic recovered"}}).Marshal()
PanicHandler(r)
}
}
}()
in := new(pb.RpcGalleryDownloadIndexRequest)
if err := in.Unmarshal(b); err != nil {
resp, _ = (&pb.RpcGalleryDownloadIndexResponse{Error: &pb.RpcGalleryDownloadIndexResponseError{Code: pb.RpcGalleryDownloadIndexResponseError_BAD_INPUT, Description: err.Error()}}).Marshal()
return resp
}
resp, _ = clientCommandsHandler.GalleryDownloadIndex(context.Background(), in).Marshal()
return resp
}
@ -5236,8 +5258,10 @@ func CommandAsync(cmd string, data []byte, callback func(data []byte)) {
cd = UnsplashSearch(data)
case "UnsplashDownload":
cd = UnsplashDownload(data)
case "DownloadManifest":
cd = DownloadManifest(data)
case "GalleryDownloadManifest":
cd = GalleryDownloadManifest(data)
case "GalleryDownloadIndex":
cd = GalleryDownloadIndex(data)
case "BlockUpload":
cd = BlockUpload(data)
case "BlockReplace":
@ -7116,19 +7140,33 @@ func (h *ClientCommandsHandlerProxy) UnsplashDownload(ctx context.Context, req *
call, _ := actualCall(ctx, req)
return call.(*pb.RpcUnsplashDownloadResponse)
}
func (h *ClientCommandsHandlerProxy) DownloadManifest(ctx context.Context, req *pb.RpcDownloadManifestRequest) *pb.RpcDownloadManifestResponse {
func (h *ClientCommandsHandlerProxy) GalleryDownloadManifest(ctx context.Context, req *pb.RpcGalleryDownloadManifestRequest) *pb.RpcGalleryDownloadManifestResponse {
actualCall := func(ctx context.Context, req any) (any, error) {
return h.client.DownloadManifest(ctx, req.(*pb.RpcDownloadManifestRequest)), nil
return h.client.GalleryDownloadManifest(ctx, req.(*pb.RpcGalleryDownloadManifestRequest)), nil
}
for _, interceptor := range h.interceptors {
toCall := actualCall
currentInterceptor := interceptor
actualCall = func(ctx context.Context, req any) (any, error) {
return currentInterceptor(ctx, req, "DownloadManifest", toCall)
return currentInterceptor(ctx, req, "GalleryDownloadManifest", toCall)
}
}
call, _ := actualCall(ctx, req)
return call.(*pb.RpcDownloadManifestResponse)
return call.(*pb.RpcGalleryDownloadManifestResponse)
}
func (h *ClientCommandsHandlerProxy) GalleryDownloadIndex(ctx context.Context, req *pb.RpcGalleryDownloadIndexRequest) *pb.RpcGalleryDownloadIndexResponse {
actualCall := func(ctx context.Context, req any) (any, error) {
return h.client.GalleryDownloadIndex(ctx, req.(*pb.RpcGalleryDownloadIndexRequest)), nil
}
for _, interceptor := range h.interceptors {
toCall := actualCall
currentInterceptor := interceptor
actualCall = func(ctx context.Context, req any) (any, error) {
return currentInterceptor(ctx, req, "GalleryDownloadIndex", toCall)
}
}
call, _ := actualCall(ctx, req)
return call.(*pb.RpcGalleryDownloadIndexResponse)
}
func (h *ClientCommandsHandlerProxy) BlockUpload(ctx context.Context, req *pb.RpcBlockUploadRequest) *pb.RpcBlockUploadResponse {
actualCall := func(ctx context.Context, req any) (any, error) {

24
core/account.go
View file

@ -2,7 +2,6 @@ package core
import (
"context"
"errors"
"github.com/anyproto/any-sync/net"
"google.golang.org/grpc/peer"
@ -201,27 +200,16 @@ func (mw *Middleware) AccountLocalLinkNewChallenge(ctx context.Context, request
info := getClientInfo(ctx)
challengeId, err := mw.applicationService.LinkLocalStartNewChallenge(&info)
if err != nil {
var code pb.RpcAccountLocalLinkNewChallengeResponseErrorCode
if errors.Is(err, session.ErrTooManyChallengeRequests) {
code = pb.RpcAccountLocalLinkNewChallengeResponseError_TOO_MANY_REQUESTS
} else {
code = pb.RpcAccountLocalLinkNewChallengeResponseError_UNKNOWN_ERROR
}
return &pb.RpcAccountLocalLinkNewChallengeResponse{
Error: &pb.RpcAccountLocalLinkNewChallengeResponseError{
Code: code,
Description: err.Error(),
},
}
}
code := mapErrorCode(err,
errToCode(session.ErrTooManyChallengeRequests, pb.RpcAccountLocalLinkNewChallengeResponseError_TOO_MANY_REQUESTS),
errToCode(application.ErrApplicationIsNotRunning, pb.RpcAccountLocalLinkNewChallengeResponseError_ACCOUNT_IS_NOT_RUNNING),
)
// todo: implement errors
return &pb.RpcAccountLocalLinkNewChallengeResponse{
ChallengeId: challengeId,
Error: &pb.RpcAccountLocalLinkNewChallengeResponseError{
Code: 0,
Description: "",
Code: code,
Description: getErrorDescription(err),
},
}
}

7
core/application/sessions.go
View file

@ -52,6 +52,10 @@ func (s *Service) ValidateSessionToken(token string) error {
}
func (s *Service) LinkLocalStartNewChallenge(clientInfo *pb.EventAccountLinkChallengeClientInfo) (id string, err error) {
if s.app == nil {
return "", ErrApplicationIsNotRunning
}
id, value, err := s.sessions.StartNewChallenge(clientInfo)
if err != nil {
return "", err
@ -72,6 +76,9 @@ func (s *Service) LinkLocalStartNewChallenge(clientInfo *pb.EventAccountLinkChal
}
func (s *Service) LinkLocalSolveChallenge(req *pb.RpcAccountLocalLinkSolveChallengeRequest) (token string, appKey string, err error) {
if s.app == nil {
return "", "", ErrApplicationIsNotRunning
}
clientInfo, token, err := s.sessions.SolveChallenge(req.ChallengeId, req.Answer, s.sessionSigningKey)
if err != nil {
return "", "", err

2
core/block.go
View file

@ -1125,7 +1125,7 @@ func (mw *Middleware) BlockPreview(cctx context.Context, req *pb.RpcBlockPreview
}
return m
}
blocks, _, err := anymark.HTMLToBlocks([]byte(req.Html), "")
blocks, _, err := anymark.HTMLToBlocks([]byte(req.Html), req.Url)
if err != nil {
return response(pb.RpcBlockPreviewResponseError_UNKNOWN_ERROR, nil, err)
}

2
core/block/delete.go
View file

@ -63,7 +63,7 @@ func (s *Service) DeleteObjectByFullID(id domain.FullID) (err error) {
case coresb.SmartBlockTypeSubObject:
return fmt.Errorf("subobjects deprecated")
case coresb.SmartBlockTypeFileObject:
err = s.fileObjectService.DeleteFileData(context.Background(), spc, id.ObjectID)
err = s.fileObjectService.DeleteFileData(id.ObjectID)
if err != nil {
return fmt.Errorf("delete file data: %w", err)
}

2
core/block/editor/clipboard/clipboard.go
View file

@ -286,7 +286,7 @@ func (cb *clipboard) Export(req pb.RpcBlockExportRequest) (path string, err erro
}
func (cb *clipboard) pasteHtml(ctx session.Context, req *pb.RpcBlockPasteRequest, groupId string) (blockIds []string, uploadArr []pb.RpcBlockUploadRequest, caretPosition int32, isSameBlockCaret bool, err error) {
blocks, _, err := anymark.HTMLToBlocks([]byte(req.HtmlSlot), "")
blocks, _, err := anymark.HTMLToBlocks([]byte(req.HtmlSlot), req.Url)
if err != nil {
return blockIds, uploadArr, caretPosition, isSameBlockCaret, err

73
core/block/editor/files.go
View file

@ -3,7 +3,6 @@ package editor
import (
"context"
"fmt"
"strings"
"github.com/anyproto/anytype-heart/core/block/editor/basic"
"github.com/anyproto/anytype-heart/core/block/editor/smartblock"
@ -11,13 +10,8 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/stext"
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/block/migration"
fileblock "github.com/anyproto/anytype-heart/core/block/simple/file"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/filestorage"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
"github.com/anyproto/anytype-heart/util/pbtypes"
)
func (f *ObjectFactory) newFile(sb smartblock.SmartBlock) *File {
@ -43,83 +37,18 @@ func (p *File) CreationStateMigration(ctx *smartblock.InitContext) migration.Mig
ctx.State.SetObjectTypeKeys(ctx.ObjectTypeKeys)
}
details := ctx.State.CombinedDetails()
fileType := fileblock.DetectTypeByMIME(pbtypes.GetString(details, bundle.RelationKeyFileMimeType.String()))
fname := pbtypes.GetString(details, bundle.RelationKeyName.String())
ext := pbtypes.GetString(details, bundle.RelationKeyFileExt.String())
if ext != "" && !strings.HasSuffix(fname, "."+ext) {
fname = fname + "." + ext
}
var blocks []*model.Block
blocks = append(blocks, &model.Block{
Id: "file",
Content: &model.BlockContentOfFile{
File: &model.BlockContentFile{
Name: fname,
Mime: pbtypes.GetString(details, bundle.RelationKeyFileMimeType.String()),
TargetObjectId: p.Id(),
Type: fileType,
Size_: int64(pbtypes.GetFloat64(details, bundle.RelationKeySizeInBytes.String())),
State: model.BlockContentFile_Done,
AddedAt: int64(pbtypes.GetFloat64(details, bundle.RelationKeyFileMimeType.String())),
},
}})
switch fileType {
case model.BlockContentFile_Image:
s.SetDetailAndBundledRelation(bundle.RelationKeyIconImage, pbtypes.String(p.Id()))
if pbtypes.GetInt64(details, bundle.RelationKeyWidthInPixels.String()) != 0 {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeyWidthInPixels))
}
if pbtypes.GetInt64(details, bundle.RelationKeyHeightInPixels.String()) != 0 {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeyHeightInPixels))
}
if pbtypes.GetString(details, bundle.RelationKeyCamera.String()) != "" {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeyCamera))
}
if pbtypes.GetInt64(details, bundle.RelationKeySizeInBytes.String()) != 0 {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeySizeInBytes))
}
if pbtypes.GetString(details, bundle.RelationKeyMediaArtistName.String()) != "" {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeyMediaArtistName))
}
if pbtypes.GetString(details, bundle.RelationKeyMediaArtistURL.String()) != "" {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeyMediaArtistURL))
}
default:
blocks = append(blocks, makeRelationBlock(bundle.RelationKeySizeInBytes))
}
// Other blocks added in file indexer (see fileobject package)
template.InitTemplate(s,
template.WithEmpty,
template.WithTitle,
template.WithDefaultFeaturedRelations,
template.WithFeaturedRelations,
template.WithRootBlocks(blocks),
template.WithAllBlocksEditsRestricted,
)
},
}
}
func makeRelationBlock(relationKey domain.RelationKey) *model.Block {
return &model.Block{
Id: relationKey.String(),
Content: &model.BlockContentOfRelation{
Relation: &model.BlockContentRelation{
Key: relationKey.String(),
},
},
}
}
func (p *File) StateMigrations() migration.Migrations {
return migration.MakeMigrations(nil)
}

17
core/block/editor/template/template.go
View file

@ -438,23 +438,6 @@ var WithAllBlocksEditsRestricted = StateTransformer(func(s *state.State) {
})
})
var WithRootBlocks = func(blocks []*model.Block) StateTransformer {
return func(s *state.State) {
WithEmpty(s)
for _, block := range blocks {
if block.Id == "" {
panic("WithRootBlocks arg must contains exact ids for blocks")
}
s.Add(simple.New(block))
err := s.InsertTo(s.RootId(), model.Block_Inner, block.Id)
if err != nil {
log.Errorf("template WithDataview failed to insert: %v", err)
}
}
}
}
var WithDataviewID = func(id string, dataview *model.BlockContentOfDataview, forceViews bool) StateTransformer {
return func(s *state.State) {
WithEmpty(s)

3
core/block/export/export.go
View file

@ -364,7 +364,8 @@ func (e *export) getExistedObjects(spaceID string, includeArchived bool, isProto
for _, info := range res {
sbType, err := e.sbtProvider.Type(spaceID, info.Id)
if err != nil {
return nil, fmt.Errorf("get smartblock type: %w", err)
log.With("objectId", info.Id).Errorf("failed to get smartblock type: %v", err)
continue
}
if !e.objectValid(sbType, info.Id, info, includeArchived, isProtobuf) {
continue

2
core/block/files.go
View file

@ -80,7 +80,7 @@ func (s *Service) DownloadFile(ctx context.Context, req *pb.RpcFileDownloadReque
}
func (s *Service) getFileOrLargestImage(ctx context.Context, objectId string) (files.File, error) {
id, err := s.fileObjectService.GetFileIdFromObject(ctx, objectId)
id, err := s.fileObjectService.GetFileIdFromObject(objectId)
if err != nil {
return nil, fmt.Errorf("get file hash from object: %w", err)
}

5
core/block/import/common/objectid/fileobject.go
View file

@ -2,10 +2,10 @@ package objectid
import (
"context"
"fmt"
"time"
"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
"go.uber.org/zap"
"github.com/anyproto/anytype-heart/core/block"
"github.com/anyproto/anytype-heart/core/block/import/common"
@ -34,7 +34,8 @@ func (o *fileObject) GetIDAndPayload(ctx context.Context, spaceId string, sn *co
if filePath != "" {
fileObjectId, err := uploadFile(ctx, o.blockService, spaceId, filePath, origin)
if err != nil {
return "", treestorage.TreeStorageCreatePayload{}, fmt.Errorf("upload file: %w", err)
log.Error("handling file object: upload file", zap.Error(err))
return id, payload, nil
}
return fileObjectId, treestorage.TreeStorageCreatePayload{}, nil
}

7
core/block/import/common/objectid/oldfile.go
View file

@ -7,6 +7,7 @@ import (
"time"
"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
"go.uber.org/zap"
"github.com/anyproto/anytype-heart/core/block"
"github.com/anyproto/anytype-heart/core/block/import/common"
@ -31,9 +32,11 @@ func (f *oldFile) GetIDAndPayload(ctx context.Context, spaceId string, sn *commo
if filePath != "" {
fileObjectId, err := uploadFile(ctx, f.blockService, spaceId, filePath, origin)
if err != nil {
return "", treestorage.TreeStorageCreatePayload{}, fmt.Errorf("upload file: %w", err)
log.Error("handling old file object: upload file", zap.Error(err))
}
if err == nil {
return fileObjectId, treestorage.TreeStorageCreatePayload{}, nil
}
return fileObjectId, treestorage.TreeStorageCreatePayload{}, nil
}
fileId := pbtypes.GetString(sn.Snapshot.Data.Details, bundle.RelationKeyId.String())

3
core/block/import/common/objectid/provider.go
View file

@ -15,9 +15,12 @@ import (
sb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/filestore"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"
"github.com/anyproto/anytype-heart/pkg/lib/logging"
"github.com/anyproto/anytype-heart/space"
)
var log = logging.Logger("import").Desugar()
type IDProvider interface {
GetIDAndPayload(ctx context.Context, spaceID string, sn *common.Snapshot, createdTime time.Time, getExisting bool, origin objectorigin.ObjectOrigin) (string, treestorage.TreeStorageCreatePayload, error)
}

27
core/block/simple/dataview/dataview.go
View file

@ -221,6 +221,33 @@ func (l *Dataview) FillSmartIds(ids []string) []string {
if view.DefaultTemplateId != "" {
ids = append(ids, view.DefaultTemplateId)
}
ids = append(ids, getIdsFromFilters(view.Filters)...)
}
return ids
}
func getIdsFromFilters(filters []*model.BlockContentDataviewFilter) (ids []string) {
for _, filter := range filters {
if filter.Format != model.RelationFormat_object &&
filter.Format != model.RelationFormat_status &&
filter.Format != model.RelationFormat_tag {
continue
}
id := filter.Value.GetStringValue()
if id != "" {
ids = append(ids, id)
continue
}
list := filter.Value.GetListValue()
if list == nil {
continue
}
for _, value := range list.Values {
ids = append(ids, value.GetStringValue())
}
}
return ids

47
core/block/simple/dataview/dataview_test.go Normal file
View file

@ -0,0 +1,47 @@
package dataview
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
"github.com/anyproto/anytype-heart/util/pbtypes"
)
func TestDataview_FillSmartIds(t *testing.T) {
obj1 := "obj1"
obj2 := "obj2"
obj3 := "obj3"
t.Run("object ids should be added from filter", func(t *testing.T) {
// given
var ids []string
d := Dataview{content: &model.BlockContentDataview{
Views: []*model.BlockContentDataviewView{{
Filters: []*model.BlockContentDataviewFilter{{
Format: model.RelationFormat_object,
Value: pbtypes.StringList([]string{obj1, obj2}),
}, {
Format: model.RelationFormat_tag,
Value: pbtypes.String(obj3),
}, {
Format: model.RelationFormat_number,
Value: pbtypes.Int64(555),
}, {
Format: model.RelationFormat_longtext,
Value: pbtypes.String("hello"),
}},
}},
}}
// when
ids = d.FillSmartIds(ids)
// then
assert.Contains(t, ids, obj1)
assert.Contains(t, ids, obj2)
assert.Contains(t, ids, obj3)
assert.Len(t, ids, 3)
})
}

10
core/block/simple/dataview/views.go
View file

@ -18,6 +18,7 @@ func (l *Dataview) AddFilter(viewID string, filter *model.BlockContentDataviewFi
if filter.Id == "" {
filter.Id = bson.NewObjectId().Hex()
}
l.setRelationFormat(filter)
view.Filters = append(view.Filters, filter)
return nil
}
@ -52,6 +53,7 @@ func (l *Dataview) ReplaceFilter(viewID string, filterID string, filter *model.B
}
filter.Id = filterID
l.setRelationFormat(filter)
view.Filters[idx] = filter
return nil
@ -207,3 +209,11 @@ func (l *Dataview) ReorderViewRelations(viewID string, relationKeys []string) er
}
return nil
}
func (l *Dataview) setRelationFormat(filter *model.BlockContentDataviewFilter) {
for _, relLink := range l.content.RelationLinks {
if relLink.Key == filter.RelationKey {
filter.Format = relLink.Format
}
}
}

2
core/converter/html/html.go
View file

@ -182,7 +182,7 @@ func (h *HTML) renderFile(b *model.Block) {
h.renderChildren(b)
h.buf.WriteString("</div>")
case model.BlockContentFile_Image:
fileId, err := h.fileObjectService.GetFileIdFromObject(context.Background(), file.TargetObjectId)
fileId, err := h.fileObjectService.GetFileIdFromObject(file.TargetObjectId)
if err == nil {
baseImg := h.getImageBase64(fileId)
fmt.Fprintf(h.buf, `<div><img alt="%s" src="%s" />`, html.EscapeString(file.Name), baseImg)

25
core/external.go
View file

@ -92,14 +92,14 @@ func (mw *Middleware) UnsplashDownload(cctx context.Context, req *pb.RpcUnsplash
return response(objectId, err)
}
func (mw *Middleware) DownloadManifest(_ context.Context, req *pb.RpcDownloadManifestRequest) *pb.RpcDownloadManifestResponse {
response := func(info *pb.RpcDownloadManifestResponseManifestInfo, err error) *pb.RpcDownloadManifestResponse {
m := &pb.RpcDownloadManifestResponse{
Error: &pb.RpcDownloadManifestResponseError{Code: pb.RpcDownloadManifestResponseError_NULL},
func (mw *Middleware) GalleryDownloadManifest(_ context.Context, req *pb.RpcGalleryDownloadManifestRequest) *pb.RpcGalleryDownloadManifestResponse {
response := func(info *model.ManifestInfo, err error) *pb.RpcGalleryDownloadManifestResponse {
m := &pb.RpcGalleryDownloadManifestResponse{
Error: &pb.RpcGalleryDownloadManifestResponseError{Code: pb.RpcGalleryDownloadManifestResponseError_NULL},
Info: info,
}
if err != nil {
m.Error.Code = pb.RpcDownloadManifestResponseError_UNKNOWN_ERROR
m.Error.Code = pb.RpcGalleryDownloadManifestResponseError_UNKNOWN_ERROR
m.Error.Description = err.Error()
}
return m
@ -107,3 +107,18 @@ func (mw *Middleware) DownloadManifest(_ context.Context, req *pb.RpcDownloadMan
info, err := gallery.DownloadManifest(req.Url, true)
return response(info, err)
}
func (mw *Middleware) GalleryDownloadIndex(_ context.Context, _ *pb.RpcGalleryDownloadIndexRequest) *pb.RpcGalleryDownloadIndexResponse {
response, err := gallery.DownloadGalleryIndex()
if response == nil {
response = &pb.RpcGalleryDownloadIndexResponse{}
}
response.Error = &pb.RpcGalleryDownloadIndexResponseError{
Code: mapErrorCode(err,
errToCode(gallery.ErrUnmarshalJson, pb.RpcGalleryDownloadIndexResponseError_UNMARSHALLING_ERROR),
errToCode(gallery.ErrDownloadIndex, pb.RpcGalleryDownloadIndexResponseError_DOWNLOAD_ERROR),
),
Description: getErrorDescription(err),
}
return response
}

2
core/file.go
View file

@ -133,7 +133,7 @@ func (mw *Middleware) FileUpload(cctx context.Context, req *pb.RpcFileUploadRequ
details *types.Struct
)
err := mw.doBlockService(func(bs *block.Service) (err error) {
dto := block.FileUploadRequest{RpcFileUploadRequest: *req, ObjectOrigin: objectorigin.None()}
dto := block.FileUploadRequest{RpcFileUploadRequest: *req, ObjectOrigin: objectorigin.ObjectOrigin{Origin: req.Origin}}
objectId, details, err = bs.UploadFile(cctx, req.SpaceId, dto)
return
})

2
core/files/fileacl/service.go
View file

@ -45,7 +45,7 @@ func (s *service) Name() (name string) {
}
func (s *service) GetInfoForFileSharing(ctx context.Context, fileObjectId string) (cid string, encryptionKeys []*model.FileEncryptionKey, err error) {
fileId, err := s.fileObjectService.GetFileIdFromObject(ctx, fileObjectId)
fileId, err := s.fileObjectService.GetFileIdFromObject(fileObjectId)
if err != nil {
return "", nil, fmt.Errorf("get file id from object: %w", err)
}

116
core/files/fileobject/fileindex.go
View file

@ -2,7 +2,9 @@ package fileobject
import (
"context"
"errors"
"fmt"
"strings"
"sync"
"time"
@ -10,6 +12,10 @@ import (
"github.com/gogo/protobuf/types"
"github.com/anyproto/anytype-heart/core/block/editor/smartblock"
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/editor/template"
"github.com/anyproto/anytype-heart/core/block/simple"
fileblock "github.com/anyproto/anytype-heart/core/block/simple/file"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
@ -173,8 +179,12 @@ func (ind *indexer) indexFile(ctx context.Context, id domain.FullID, fileId doma
defer ind.markIndexingDone(id)
details, typeKey, err := ind.buildDetails(ctx, fileId)
if errors.Is(err, domain.ErrFileNotFound) {
log.Errorf("build details: %v", err)
return ind.markFileAsNotFound(id)
}
if err != nil {
return fmt.Errorf("get details for file or image: %w", err)
return fmt.Errorf("build details: %w", err)
}
space, err := ind.spaceService.Get(ctx, id.SpaceID)
if err != nil {
@ -184,8 +194,20 @@ func (ind *indexer) indexFile(ctx context.Context, id domain.FullID, fileId doma
st := sb.NewState()
st.SetObjectTypeKey(typeKey)
prevDetails := st.CombinedDetails()
keys := make([]domain.RelationKey, 0, len(details.Fields))
for k := range details.Fields {
keys = append(keys, domain.RelationKey(k))
}
st.AddBundledRelations(keys...)
details = pbtypes.StructMerge(prevDetails, details, true)
st.SetDetails(details)
err = ind.addBlocks(st, details, id.ObjectID)
if err != nil {
return fmt.Errorf("add blocks: %w", err)
}
return sb.Apply(st)
})
if err != nil {
@ -194,6 +216,18 @@ func (ind *indexer) indexFile(ctx context.Context, id domain.FullID, fileId doma
return nil
}
func (ind *indexer) markFileAsNotFound(id domain.FullID) error {
space, err := ind.spaceService.Get(ind.indexCtx, id.SpaceID)
if err != nil {
return fmt.Errorf("get space: %w", err)
}
return space.Do(id.ObjectID, func(sb smartblock.SmartBlock) error {
st := sb.NewState()
st.SetDetailAndBundledRelation(bundle.RelationKeyFileIndexingStatus, pbtypes.Int64(int64(model.FileIndexingStatus_NotFound)))
return sb.Apply(st)
})
}
func (ind *indexer) buildDetails(ctx context.Context, id domain.FullFileId) (details *types.Struct, typeKey domain.TypeKey, err error) {
file, err := ind.fileService.FileByHash(ctx, id)
if err != nil {
@ -218,3 +252,83 @@ func (ind *indexer) buildDetails(ctx context.Context, id domain.FullFileId) (det
details.Fields[bundle.RelationKeyFileIndexingStatus.String()] = pbtypes.Int64(int64(model.FileIndexingStatus_Indexed))
return details, typeKey, nil
}
func (ind *indexer) addBlocks(st *state.State, details *types.Struct, objectId string) error {
fileType := fileblock.DetectTypeByMIME(pbtypes.GetString(details, bundle.RelationKeyFileMimeType.String()))
fname := pbtypes.GetString(details, bundle.RelationKeyName.String())
ext := pbtypes.GetString(details, bundle.RelationKeyFileExt.String())
if ext != "" && !strings.HasSuffix(fname, "."+ext) {
fname = fname + "." + ext
}
var blocks []*model.Block
blocks = append(blocks, &model.Block{
Id: "file",
Content: &model.BlockContentOfFile{
File: &model.BlockContentFile{
Name: fname,
Mime: pbtypes.GetString(details, bundle.RelationKeyFileMimeType.String()),
TargetObjectId: objectId,
Type: fileType,
Size_: int64(pbtypes.GetFloat64(details, bundle.RelationKeySizeInBytes.String())),
State: model.BlockContentFile_Done,
AddedAt: int64(pbtypes.GetFloat64(details, bundle.RelationKeyFileMimeType.String())),
},
}})
switch fileType {
case model.BlockContentFile_Image:
st.SetDetailAndBundledRelation(bundle.RelationKeyIconImage, pbtypes.String(objectId))
if pbtypes.GetInt64(details, bundle.RelationKeyWidthInPixels.String()) != 0 {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeyWidthInPixels))
}
if pbtypes.GetInt64(details, bundle.RelationKeyHeightInPixels.String()) != 0 {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeyHeightInPixels))
}
if pbtypes.GetString(details, bundle.RelationKeyCamera.String()) != "" {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeyCamera))
}
if pbtypes.GetInt64(details, bundle.RelationKeySizeInBytes.String()) != 0 {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeySizeInBytes))
}
if pbtypes.GetString(details, bundle.RelationKeyMediaArtistName.String()) != "" {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeyMediaArtistName))
}
if pbtypes.GetString(details, bundle.RelationKeyMediaArtistURL.String()) != "" {
blocks = append(blocks, makeRelationBlock(bundle.RelationKeyMediaArtistURL))
}
default:
blocks = append(blocks, makeRelationBlock(bundle.RelationKeySizeInBytes))
}
for _, b := range blocks {
if st.Exists(b.Id) {
st.Set(simple.New(b))
} else {
st.Add(simple.New(b))
err := st.InsertTo(st.RootId(), model.Block_Inner, b.Id)
if err != nil {
return fmt.Errorf("failed to insert file block: %w", err)
}
}
}
template.WithAllBlocksEditsRestricted(st)
return nil
}
func makeRelationBlock(relationKey domain.RelationKey) *model.Block {
return &model.Block{
Id: relationKey.String(),
Content: &model.BlockContentOfRelation{
Relation: &model.BlockContentRelation{
Key: relationKey.String(),
},
},
}
}

52
core/files/fileobject/mock_fileobject/mock_Service.go
View file

@ -6,7 +6,6 @@ import (
context "context"
app "github.com/anyproto/any-sync/app"
clientspace "github.com/anyproto/anytype-heart/space/clientspace"
domain "github.com/anyproto/anytype-heart/core/domain"
@ -208,17 +207,17 @@ func (_c *MockService_CreateFromImport_Call) RunAndReturn(run func(domain.FullFi
return _c
}
// DeleteFileData provides a mock function with given fields: ctx, space, objectId
func (_m *MockService) DeleteFileData(ctx context.Context, space clientspace.Space, objectId string) error {
ret := _m.Called(ctx, space, objectId)
// DeleteFileData provides a mock function with given fields: objectId
func (_m *MockService) DeleteFileData(objectId string) error {
ret := _m.Called(objectId)
if len(ret) == 0 {
panic("no return value specified for DeleteFileData")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, clientspace.Space, string) error); ok {
r0 = rf(ctx, space, objectId)
if rf, ok := ret.Get(0).(func(string) error); ok {
r0 = rf(objectId)
} else {
r0 = ret.Error(0)
}
@ -232,16 +231,14 @@ type MockService_DeleteFileData_Call struct {
}
// DeleteFileData is a helper method to define mock.On call
// - ctx context.Context
// - space clientspace.Space
// - objectId string
func (_e *MockService_Expecter) DeleteFileData(ctx interface{}, space interface{}, objectId interface{}) *MockService_DeleteFileData_Call {
return &MockService_DeleteFileData_Call{Call: _e.mock.On("DeleteFileData", ctx, space, objectId)}
func (_e *MockService_Expecter) DeleteFileData(objectId interface{}) *MockService_DeleteFileData_Call {
return &MockService_DeleteFileData_Call{Call: _e.mock.On("DeleteFileData", objectId)}
}
func (_c *MockService_DeleteFileData_Call) Run(run func(ctx context.Context, space clientspace.Space, objectId string)) *MockService_DeleteFileData_Call {
func (_c *MockService_DeleteFileData_Call) Run(run func(objectId string)) *MockService_DeleteFileData_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(clientspace.Space), args[2].(string))
run(args[0].(string))
})
return _c
}
@ -251,7 +248,7 @@ func (_c *MockService_DeleteFileData_Call) Return(_a0 error) *MockService_Delete
return _c
}
func (_c *MockService_DeleteFileData_Call) RunAndReturn(run func(context.Context, clientspace.Space, string) error) *MockService_DeleteFileData_Call {
func (_c *MockService_DeleteFileData_Call) RunAndReturn(run func(string) error) *MockService_DeleteFileData_Call {
_c.Call.Return(run)
return _c
}
@ -444,9 +441,9 @@ func (_c *MockService_FilesOffload_Call) RunAndReturn(run func(context.Context,
return _c
}
// GetFileIdFromObject provides a mock function with given fields: ctx, objectId
func (_m *MockService) GetFileIdFromObject(ctx context.Context, objectId string) (domain.FullFileId, error) {
ret := _m.Called(ctx, objectId)
// GetFileIdFromObject provides a mock function with given fields: objectId
func (_m *MockService) GetFileIdFromObject(objectId string) (domain.FullFileId, error) {
ret := _m.Called(objectId)
if len(ret) == 0 {
panic("no return value specified for GetFileIdFromObject")
@ -454,17 +451,17 @@ func (_m *MockService) GetFileIdFromObject(ctx context.Context, objectId string)
var r0 domain.FullFileId
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string) (domain.FullFileId, error)); ok {
return rf(ctx, objectId)
if rf, ok := ret.Get(0).(func(string) (domain.FullFileId, error)); ok {
return rf(objectId)
}
if rf, ok := ret.Get(0).(func(context.Context, string) domain.FullFileId); ok {
r0 = rf(ctx, objectId)
if rf, ok := ret.Get(0).(func(string) domain.FullFileId); ok {
r0 = rf(objectId)
} else {
r0 = ret.Get(0).(domain.FullFileId)
}
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
r1 = rf(ctx, objectId)
if rf, ok := ret.Get(1).(func(string) error); ok {
r1 = rf(objectId)
} else {
r1 = ret.Error(1)
}
@ -478,15 +475,14 @@ type MockService_GetFileIdFromObject_Call struct {
}
// GetFileIdFromObject is a helper method to define mock.On call
// - ctx context.Context
// - objectId string
func (_e *MockService_Expecter) GetFileIdFromObject(ctx interface{}, objectId interface{}) *MockService_GetFileIdFromObject_Call {
return &MockService_GetFileIdFromObject_Call{Call: _e.mock.On("GetFileIdFromObject", ctx, objectId)}
func (_e *MockService_Expecter) GetFileIdFromObject(objectId interface{}) *MockService_GetFileIdFromObject_Call {
return &MockService_GetFileIdFromObject_Call{Call: _e.mock.On("GetFileIdFromObject", objectId)}
}
func (_c *MockService_GetFileIdFromObject_Call) Run(run func(ctx context.Context, objectId string)) *MockService_GetFileIdFromObject_Call {
func (_c *MockService_GetFileIdFromObject_Call) Run(run func(objectId string)) *MockService_GetFileIdFromObject_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(string))
run(args[0].(string))
})
return _c
}
@ -496,7 +492,7 @@ func (_c *MockService_GetFileIdFromObject_Call) Return(_a0 domain.FullFileId, _a
return _c
}
func (_c *MockService_GetFileIdFromObject_Call) RunAndReturn(run func(context.Context, string) (domain.FullFileId, error)) *MockService_GetFileIdFromObject_Call {
func (_c *MockService_GetFileIdFromObject_Call) RunAndReturn(run func(string) (domain.FullFileId, error)) *MockService_GetFileIdFromObject_Call {
_c.Call.Return(run)
return _c
}

77
core/files/fileobject/service.go
View file

@ -12,7 +12,6 @@ import (
"github.com/anyproto/anytype-heart/core/block/editor/smartblock"
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/block/object/idresolver"
"github.com/anyproto/anytype-heart/core/block/simple"
"github.com/anyproto/anytype-heart/core/block/source"
"github.com/anyproto/anytype-heart/core/domain"
@ -42,10 +41,10 @@ const CName = "fileobject"
type Service interface {
app.ComponentRunnable
DeleteFileData(ctx context.Context, space clientspace.Space, objectId string) error
DeleteFileData(objectId string) error
Create(ctx context.Context, spaceId string, req CreateRequest) (id string, object *types.Struct, err error)
CreateFromImport(fileId domain.FullFileId, origin objectorigin.ObjectOrigin) (string, error)
GetFileIdFromObject(ctx context.Context, objectId string) (domain.FullFileId, error)
GetFileIdFromObject(objectId string) (domain.FullFileId, error)
GetObjectDetailsByFileId(fileId domain.FullFileId) (string, *types.Struct, error)
MigrateDetails(st *state.State, spc source.Space, keys []*pb.ChangeFileKeys)
MigrateBlocks(st *state.State, spc source.Space, keys []*pb.ChangeFileKeys)
@ -61,7 +60,6 @@ type objectCreatorService interface {
type service struct {
spaceService space.Service
resolver idresolver.Resolver
objectCreator objectCreatorService
fileService files.Service
fileSync filesync.FileSync
@ -81,7 +79,6 @@ func (s *service) Name() string {
func (s *service) Init(a *app.App) error {
s.spaceService = app.MustComponent[space.Service](a)
s.resolver = app.MustComponent[idresolver.Resolver](a)
s.objectCreator = app.MustComponent[objectCreatorService](a)
s.fileService = app.MustComponent[files.Service](a)
s.fileSync = app.MustComponent[filesync.FileSync](a)
@ -303,35 +300,18 @@ func (s *service) GetObjectDetailsByFileId(fileId domain.FullFileId) (string, *t
return pbtypes.GetString(details, bundle.RelationKeyId.String()), details, nil
}
func (s *service) GetFileIdFromObject(ctx context.Context, objectId string) (domain.FullFileId, error) {
spaceId, err := s.resolver.ResolveSpaceID(objectId)
func (s *service) GetFileIdFromObject(objectId string) (domain.FullFileId, error) {
details, err := s.objectStore.GetDetails(objectId)
if err != nil {
return domain.FullFileId{}, fmt.Errorf("resolve spaceId: %w", err)
return domain.FullFileId{}, fmt.Errorf("get object details: %w", err)
}
space, err := s.spaceService.Get(ctx, spaceId)
if err != nil {
return domain.FullFileId{}, fmt.Errorf("get space: %w", err)
spaceId := pbtypes.GetString(details.Details, bundle.RelationKeySpaceId.String())
fileId := pbtypes.GetString(details.Details, bundle.RelationKeyFileId.String())
if fileId == "" {
return domain.FullFileId{}, fmt.Errorf("empty file hash")
}
return s.getFileIdFromObjectInSpace(space, objectId)
}
func (s *service) getFileIdFromObjectInSpace(space smartblock.Space, objectId string) (domain.FullFileId, error) {
var fileId string
err := space.Do(objectId, func(sb smartblock.SmartBlock) error {
fileId = pbtypes.GetString(sb.Details(), bundle.RelationKeyFileId.String())
if fileId == "" {
return fmt.Errorf("empty file hash")
}
return nil
})
if err != nil {
return domain.FullFileId{}, fmt.Errorf("get file object: %w", err)
}
return domain.FullFileId{
SpaceId: space.Id(),
SpaceId: spaceId,
FileId: domain.FileId(fileId),
}, nil
}
@ -363,6 +343,18 @@ func (s *service) migrate(space clientspace.Space, objectId string, keys []*pb.C
return fileObjectId
}
// If due to some reason fileId is a file object id from another space, we should not migrate it
// This is definitely a bug, but we should not break things further.
exists, err := s.isFileExistInAnotherSpace(space.Id(), fileId)
if err != nil {
log.Errorf("checking that file exist in another space: %v", err)
return fileId
}
if exists {
log.With("fileObjectId", fileId).Error("found file object in another space")
return fileId
}
if len(fileKeys) == 0 {
log.Warnf("no encryption keys for fileId %s", fileId)
}
@ -392,6 +384,27 @@ func (s *service) migrate(space clientspace.Space, objectId string, keys []*pb.C
return fileObjectId
}
func (s *service) isFileExistInAnotherSpace(spaceId string, fileObjectId string) (bool, error) {
recs, _, err := s.objectStore.Query(database.Query{
Filters: []*model.BlockContentDataviewFilter{
{
RelationKey: bundle.RelationKeyId.String(),
Condition: model.BlockContentDataviewFilter_Equal,
Value: pbtypes.String(fileObjectId),
},
{
RelationKey: bundle.RelationKeySpaceId.String(),
Condition: model.BlockContentDataviewFilter_NotEqual,
Value: pbtypes.String(spaceId),
},
},
})
if err != nil {
return false, fmt.Errorf("query objects by file hash: %w", err)
}
return len(recs) > 0, nil
}
func (s *service) MigrateBlocks(st *state.State, spc source.Space, keys []*pb.ChangeFileKeys) {
origin := objectorigin.FromDetails(st.Details())
st.Iterate(func(b simple.Block) (isContinue bool) {
@ -519,8 +532,8 @@ func (s *service) FileSpaceOffload(ctx context.Context, spaceId string, includeN
return filesOffloaded, totalSize, nil
}
func (s *service) DeleteFileData(ctx context.Context, space clientspace.Space, objectId string) error {
fullId, err := s.getFileIdFromObjectInSpace(space, objectId)
func (s *service) DeleteFileData(objectId string) error {
fullId, err := s.GetFileIdFromObject(objectId)
if err != nil {
return fmt.Errorf("get file id from object: %w", err)
}

332
core/files/fileobject/service_test.go Normal file
View file

@ -0,0 +1,332 @@
package fileobject
import (
"context"
"strings"
"testing"
"time"
"github.com/anyproto/any-sync/app"
"github.com/anyproto/any-sync/app/ocache"
"github.com/anyproto/any-sync/commonfile/fileservice"
"github.com/gogo/protobuf/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"github.com/anyproto/anytype-heart/core/block/editor/state"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/domain/objectorigin"
"github.com/anyproto/anytype-heart/core/event/mock_event"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/filestorage"
"github.com/anyproto/anytype-heart/core/filestorage/filesync"
"github.com/anyproto/anytype-heart/core/filestorage/rpcstore"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/datastore"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/filestore"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
"github.com/anyproto/anytype-heart/space/clientspace"
"github.com/anyproto/anytype-heart/space/clientspace/mock_clientspace"
"github.com/anyproto/anytype-heart/space/mock_space"
bb "github.com/anyproto/anytype-heart/tests/blockbuilder"
"github.com/anyproto/anytype-heart/tests/testutil"
"github.com/anyproto/anytype-heart/util/pbtypes"
)
type fixture struct {
fileService files.Service
objectStore *objectstore.StoreFixture
objectCreator *objectCreatorStub
spaceService *mock_space.MockService
*service
}
func newFixture(t *testing.T) *fixture {
fileStore := filestore.New()
objectStore := objectstore.NewStoreFixture(t)
objectCreator := &objectCreatorStub{}
dataStoreProvider := datastore.NewInMemory()
blockStorage := filestorage.NewInMemory()
rpcStore := rpcstore.NewInMemoryStore(1024)
rpcStoreService := rpcstore.NewInMemoryService(rpcStore)
commonFileService := fileservice.New()
fileSyncService := filesync.New()
eventSender := mock_event.NewMockSender(t)
fileService := files.New()
spaceService := mock_space.NewMockService(t)
svc := New()
ctx := context.Background()
a := new(app.App)
a.Register(dataStoreProvider)
a.Register(fileStore)
a.Register(objectStore)
a.Register(commonFileService)
a.Register(fileSyncService)
a.Register(testutil.PrepareMock(ctx, a, eventSender))
a.Register(testutil.PrepareMock(ctx, a, spaceService))
a.Register(blockStorage)
a.Register(rpcStoreService)
a.Register(fileService)
a.Register(objectCreator)
a.Register(svc)
err := a.Start(ctx)
require.NoError(t, err)
fx := &fixture{
fileService: fileService,
objectStore: objectStore,
objectCreator: objectCreator,
spaceService: spaceService,
service: svc.(*service),
}
return fx
}
type objectCreatorStub struct {
objectId string
creationState *state.State
details *types.Struct
}
func (c *objectCreatorStub) Init(_ *app.App) error {
return nil
}
func (c *objectCreatorStub) Name() string {
return "objectCreatorStub"
}
func (c *objectCreatorStub) CreateSmartBlockFromStateInSpace(ctx context.Context, space clientspace.Space, objectTypeKeys []domain.TypeKey, createState *state.State) (id string, newDetails *types.Struct, err error) {
c.creationState = createState
return c.objectId, c.details, nil
}
func TestMigration(t *testing.T) {
t.Run("do not migrate empty file ids", func(t *testing.T) {
fx := newFixture(t)
fileId := ""
st := testutil.BuildStateFromAST(
bb.Root(
bb.ID("root"),
bb.Children(bb.File("", bb.FileHash(fileId))),
),
)
space := mock_clientspace.NewMockSpace(t)
fx.MigrateBlocks(st, space, nil)
})
t.Run("do not migrate object itself", func(t *testing.T) {
fx := newFixture(t)
objectId := "objectId"
fileId := objectId
st := testutil.BuildStateFromAST(
bb.Root(
bb.ID(objectId),
bb.Children(bb.File("", bb.FileHash(fileId))),
),
)
space := mock_clientspace.NewMockSpace(t)
fx.MigrateBlocks(st, space, nil)
})
t.Run("do not migrate already migrated file: fileId equals to objectId", func(t *testing.T) {
fx := newFixture(t)
objectId := "objectId"
fileId := domain.FileId("fileId")
st := testutil.BuildStateFromAST(
bb.Root(
bb.ID(objectId),
bb.Children(bb.File("", bb.FileHash(fileId.String()))),
),
)
space := mock_clientspace.NewMockSpace(t)
space.EXPECT().Do(fileId.String(), mock.Anything).Return(nil)
fx.MigrateBlocks(st, space, nil)
})
t.Run("do not migrate already migrated file: objectId is found by fileId in current space", func(t *testing.T) {
fx := newFixture(t)
spaceId := "spaceId"
objectId := "objectId"
fileId := domain.FileId("fileId")
expectedFileObjectId := "fileObjectId"
st := testutil.BuildStateFromAST(
bb.Root(
bb.ID(objectId),
),
)
st.SetDetailAndBundledRelation(bundle.RelationKeyAttachments, pbtypes.StringList([]string{fileId.String()}))
space := mock_clientspace.NewMockSpace(t)
space.EXPECT().Do(fileId.String(), mock.Anything).Return(ocache.ErrNotExists)
space.EXPECT().Id().Return(spaceId)
fx.objectStore.AddObjects(t, []objectstore.TestObject{
{
bundle.RelationKeyId: pbtypes.String(expectedFileObjectId),
bundle.RelationKeyFileId: pbtypes.String(fileId.String()),
bundle.RelationKeySpaceId: pbtypes.String(spaceId),
},
})
fx.MigrateBlocks(st, space, nil)
fx.MigrateDetails(st, space, nil)
wantState := testutil.BuildStateFromAST(
bb.Root(
bb.ID(objectId),
),
)
wantState.SetDetailAndBundledRelation(bundle.RelationKeyAttachments, pbtypes.StringList([]string{expectedFileObjectId}))
bb.AssertTreesEqual(t, wantState.Blocks(), st.Blocks())
assert.Equal(t, wantState.Details(), st.Details())
})
t.Run("do not migrate already migrated file: objectId is found by fileId in another space", func(t *testing.T) {
fx := newFixture(t)
spaceId := "spaceId"
objectId := "objectId"
fileId := domain.FileId("fileObjectIdFromAnotherSpace")
st := testutil.BuildStateFromAST(
bb.Root(
bb.ID(objectId),
),
)
st.SetDetailAndBundledRelation(bundle.RelationKeyAttachments, pbtypes.StringList([]string{fileId.String()}))
space := mock_clientspace.NewMockSpace(t)
space.EXPECT().Do(fileId.String(), mock.Anything).Return(ocache.ErrNotExists)
space.EXPECT().Id().Return(spaceId)
fx.objectStore.AddObjects(t, []objectstore.TestObject{
{
bundle.RelationKeyId: pbtypes.String(fileId.String()),
bundle.RelationKeyFileId: pbtypes.String("fileId"),
bundle.RelationKeySpaceId: pbtypes.String("spaceId2"),
},
})
fx.MigrateBlocks(st, space, nil)
fx.MigrateDetails(st, space, nil)
wantState := testutil.BuildStateFromAST(
bb.Root(
bb.ID(objectId),
),
)
wantState.SetDetailAndBundledRelation(bundle.RelationKeyAttachments, pbtypes.StringList([]string{fileId.String()}))
bb.AssertTreesEqual(t, wantState.Blocks(), st.Blocks())
assert.Equal(t, wantState.Details(), st.Details())
})
t.Run("when file is not migrated yet: derive new object", func(t *testing.T) {
fx := newFixture(t)
spaceId := "spaceId"
addedFile := testAddFile(t, fx, spaceId)
objectId := "objectId"
fileId := addedFile.FileId
expectedFileObjectId := "fileObjectId"
st := testutil.BuildStateFromAST(
bb.Root(
bb.ID(objectId),
bb.Children(
bb.File("", bb.FileHash(fileId.String())),
bb.Text("sample text", bb.TextIconImage(fileId.String())),
),
),
)
st.SetDetailAndBundledRelation(bundle.RelationKeyIconImage, pbtypes.StringList([]string{fileId.String()}))
space := mock_clientspace.NewMockSpace(t)
space.EXPECT().Do(fileId.String(), mock.Anything).Return(ocache.ErrNotExists)
space.EXPECT().Id().Return(spaceId)
space.EXPECT().DeriveObjectIdWithAccountSignature(mock.Anything, mock.Anything).Return(expectedFileObjectId, nil)
origin := objectorigin.Import(model.Import_Html)
err := fx.fileStore.SetFileOrigin(fileId, origin)
require.NoError(t, err)
fx.objectCreator.objectId = expectedFileObjectId
expectIndexerCalled(t, fx, expectedFileObjectId)
keys := map[string]string{
"filepath": "key",
}
keysChanges := []*pb.ChangeFileKeys{
{
Hash: fileId.String(),
Keys: keys,
},
}
fx.MigrateBlocks(st, space, keysChanges)
fx.MigrateDetails(st, space, keysChanges)
assert.Equal(t, pbtypes.GetInt64(fx.objectCreator.creationState.Details(), bundle.RelationKeyOrigin.String()), int64(origin.Origin))
assert.Equal(t, pbtypes.GetInt64(fx.objectCreator.creationState.Details(), bundle.RelationKeyImportType.String()), int64(origin.ImportType))
assert.Equal(t, state.FileInfo{
FileId: fileId,
EncryptionKeys: keys,
}, fx.objectCreator.creationState.GetFileInfo())
wantState := testutil.BuildStateFromAST(
bb.Root(
bb.ID(objectId),
bb.Children(
bb.File(expectedFileObjectId, bb.FileHash(fileId.String())),
bb.Text("sample text", bb.TextIconImage(expectedFileObjectId)),
),
),
)
wantState.SetDetailAndBundledRelation(bundle.RelationKeyIconImage, pbtypes.StringList([]string{expectedFileObjectId}))
bb.AssertTreesEqual(t, wantState.Blocks(), st.Blocks())
assert.Equal(t, wantState.Details(), st.Details())
})
}
func testAddFile(t *testing.T, fx *fixture, spaceId string) *files.AddResult {
fileName := "myFile"
lastModifiedDate := time.Now()
fileContent := "it's my favorite file"
buf := strings.NewReader(fileContent)
opts := []files.AddOption{
files.WithName(fileName),
files.WithLastModifiedDate(lastModifiedDate.Unix()),
files.WithReader(buf),
}
got, err := fx.fileService.FileAdd(context.Background(), spaceId, opts...)
require.NoError(t, err)
got.Commit()
return got
}
func expectIndexerCalled(t *testing.T, fx *fixture, fileObjectId string) {
space := mock_clientspace.NewMockSpace(t)
space.EXPECT().Do(fileObjectId, mock.Anything).Return(nil)
fx.spaceService.EXPECT().Get(mock.Anything, mock.Anything).Return(space, nil)
}

99
core/files/files.go
View file

@ -11,6 +11,7 @@ import (
"io/ioutil"
"path"
"strings"
"sync"
"time"
"github.com/anyproto/any-sync/app"
@ -23,7 +24,6 @@ import (
"github.com/multiformats/go-base32"
mh "github.com/multiformats/go-multihash"
"github.com/anyproto/anytype-heart/core/block/object/idresolver"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/filestorage"
"github.com/anyproto/anytype-heart/core/filestorage/filesync"
@ -55,13 +55,13 @@ var log = logging.Logger("anytype-files")
var _ Service = (*service)(nil)
type Service interface {
FileAdd(ctx context.Context, spaceID string, options ...AddOption) (*FileAddResult, error)
FileAdd(ctx context.Context, spaceID string, options ...AddOption) (*AddResult, error)
FileByHash(ctx context.Context, id domain.FullFileId) (File, error)
FileGetKeys(id domain.FullFileId) (*domain.FileEncryptionKeys, error)
FileOffload(ctx context.Context, id domain.FullFileId) (totalSize uint64, err error)
GetSpaceUsage(ctx context.Context, spaceID string) (*pb.RpcFileSpaceUsageResponseUsage, error)
GetNodeUsage(ctx context.Context) (*NodeUsageResponse, error)
ImageAdd(ctx context.Context, spaceID string, options ...AddOption) (*ImageAddResult, error)
ImageAdd(ctx context.Context, spaceID string, options ...AddOption) (*AddResult, error)
ImageByHash(ctx context.Context, id domain.FullFileId) (Image, error)
app.Component
@ -72,13 +72,17 @@ type service struct {
commonFile fileservice.FileService
fileSync filesync.FileSync
dagService ipld.DAGService
resolver idresolver.Resolver
fileStorage filestorage.FileStorage
objectStore objectstore.ObjectStore
lock sync.Mutex
addOperationLocks map[string]*sync.Mutex
}
func New() Service {
return &service{}
return &service{
addOperationLocks: make(map[string]*sync.Mutex),
}
}
func (s *service) Init(a *app.App) (err error) {
@ -88,7 +92,6 @@ func (s *service) Init(a *app.App) (err error) {
s.dagService = s.commonFile.DAGService()
s.fileStorage = app.MustComponent[filestorage.FileStorage](a)
s.resolver = app.MustComponent[idresolver.Resolver](a)
s.objectStore = app.MustComponent[objectstore.ObjectStore](a)
return nil
}
@ -107,39 +110,58 @@ var ValidContentLinkNames = []string{"content"}
var cidBuilder = cid.V1Builder{Codec: cid.DagProtobuf, MhType: mh.SHA2_256}
type FileAddResult struct {
type AddResult struct {
FileId domain.FileId
File File
EncryptionKeys *domain.FileEncryptionKeys
IsExisting bool // Is file already added by user?
MIME string
Size int64
lock *sync.Mutex
}
func (s *service) FileAdd(ctx context.Context, spaceId string, options ...AddOption) (*FileAddResult, error) {
// Commit transaction of adding a file
func (r *AddResult) Commit() {
r.lock.Unlock()
}
func (s *service) FileAdd(ctx context.Context, spaceId string, options ...AddOption) (*AddResult, error) {
opts := AddOptions{}
for _, opt := range options {
opt(&opts)
}
err := s.normalizeOptions(ctx, spaceId, &opts)
err := s.normalizeOptions(&opts)
if err != nil {
return nil, err
}
addLock := s.lockAddOperation(opts.checksum)
fileInfo, fileNode, err := s.addFileNode(ctx, spaceId, &m.Blob{}, opts)
if errors.Is(err, errFileExists) {
return s.newExistingFileResult(spaceId, fileInfo)
res, err := s.newExistingFileResult(addLock, fileInfo)
if err != nil {
addLock.Unlock()
return nil, err
}
return res, nil
}
if err != nil {
addLock.Unlock()
return nil, err
}
rootNode, keys, err := s.addFileRootNode(ctx, spaceId, fileInfo, fileNode)
if err != nil {
addLock.Unlock()
return nil, err
}
fileId := domain.FileId(rootNode.Cid().String())
err = s.fileStore.LinkFileVariantToFile(fileId, domain.FileContentId(fileInfo.Hash))
if err != nil {
addLock.Unlock()
return nil, fmt.Errorf("link file variant to file: %w", err)
}
@ -149,31 +171,38 @@ func (s *service) FileAdd(ctx context.Context, spaceId string, options ...AddOpt
}
err = s.fileStore.AddFileKeys(fileKeys)
if err != nil {
addLock.Unlock()
return nil, fmt.Errorf("failed to save file keys: %w", err)
}
err = s.storeFileSize(spaceId, fileId)
if err != nil {
addLock.Unlock()
return nil, fmt.Errorf("store file size: %w", err)
}
return &FileAddResult{
return &AddResult{
FileId: fileId,
File: s.newFile(spaceId, fileId, fileInfo),
EncryptionKeys: &fileKeys,
Size: fileInfo.Size_,
MIME: opts.Media,
lock: addLock,
}, nil
}
func (s *service) newExistingFileResult(spaceId string, fileInfo *storage.FileInfo) (*FileAddResult, error) {
func (s *service) newExistingFileResult(lock *sync.Mutex, fileInfo *storage.FileInfo) (*AddResult, error) {
fileId, keys, err := s.getFileIdAndEncryptionKeysFromInfo(fileInfo)
if err != nil {
return nil, err
}
return &FileAddResult{
return &AddResult{
IsExisting: true,
FileId: fileId,
File: s.newFile(spaceId, fileId, fileInfo),
EncryptionKeys: keys,
Size: fileInfo.Size_,
MIME: fileInfo.Media,
lock: lock,
}, nil
}
@ -455,21 +484,6 @@ var errFileExists = errors.New("file exists")
- content
*/
func (s *service) addFileNode(ctx context.Context, spaceID string, mill m.Mill, conf AddOptions) (*storage.FileInfo, ipld.Node, error) {
var source string
if conf.Use != "" {
source = conf.Use
} else {
var err error
source, err = checksum(conf.Reader, false)
if err != nil {
return nil, nil, fmt.Errorf("failed to calculate checksum: %w", err)
}
_, err = conf.Reader.Seek(0, io.SeekStart)
if err != nil {
return nil, nil, fmt.Errorf("failed to seek reader: %w", err)
}
}
opts, err := mill.Options(map[string]interface{}{
"plaintext": false,
})
@ -477,7 +491,7 @@ func (s *service) addFileNode(ctx context.Context, spaceID string, mill m.Mill,
return nil, nil, err
}
if efile, _ := s.fileStore.GetFileVariantBySource(mill.ID(), source, opts); efile != nil && efile.MetaHash != "" {
if efile, _ := s.fileStore.GetFileVariantBySource(mill.ID(), conf.checksum, opts); efile != nil && efile.MetaHash != "" {
return efile, nil, errFileExists
}
@ -488,12 +502,12 @@ func (s *service) addFileNode(ctx context.Context, spaceID string, mill m.Mill,
// count the result size after the applied mill
readerWithCounter := datacounter.NewReaderCounter(res.File)
check, err := checksum(readerWithCounter, false)
variantChecksum, err := checksum(readerWithCounter, false)
if err != nil {
return nil, nil, err
}
if efile, _ := s.fileStore.GetFileVariantByChecksum(mill.ID(), check); efile != nil && efile.MetaHash != "" {
if efile, _ := s.fileStore.GetFileVariantByChecksum(mill.ID(), variantChecksum); efile != nil && efile.MetaHash != "" {
return efile, nil, errFileExists
}
@ -510,8 +524,8 @@ func (s *service) addFileNode(ctx context.Context, spaceID string, mill m.Mill,
fileInfo := &storage.FileInfo{
Mill: mill.ID(),
Checksum: check,
Source: source,
Checksum: variantChecksum,
Source: conf.checksum,
Opts: opts,
Media: conf.Media,
Name: conf.Name,
@ -757,3 +771,16 @@ func (s *service) getInnerDirNode(ctx context.Context, dagService ipld.DAGServic
node, err := helpers.NodeAtLink(ctx, dagService, dirLink)
return node, dirLink, err
}
func (s *service) lockAddOperation(checksum string) *sync.Mutex {
s.lock.Lock()
opLock, ok := s.addOperationLocks[checksum]
if !ok {
opLock = &sync.Mutex{}
s.addOperationLocks[checksum] = opLock
}
s.lock.Unlock()
opLock.Lock()
return opLock
}

104
core/files/files_test.go
View file

@ -25,26 +25,6 @@ import (
"github.com/anyproto/anytype-heart/tests/testutil"
)
type personalSpaceIdStub struct {
personalSpaceId string
}
func (s *personalSpaceIdStub) Name() string { return "personalSpaceIdStub" }
func (s *personalSpaceIdStub) Init(a *app.App) error { return nil }
func (s *personalSpaceIdStub) PersonalSpaceID() string {
return s.personalSpaceId
}
type spaceResolverStub struct {
spaceId string
}
func (s *spaceResolverStub) Name() string { return "spaceResolverStub" }
func (s *spaceResolverStub) Init(a *app.App) error { return nil }
func (s *spaceResolverStub) ResolveSpaceID(objectID string) (string, error) {
return s.spaceId, nil
}
type fixture struct {
Service
@ -64,14 +44,8 @@ func newFixture(t *testing.T) *fixture {
rpcStore := rpcstore.NewInMemoryStore(1024)
rpcStoreService := rpcstore.NewInMemoryService(rpcStore)
commonFileService := fileservice.New()
fileSyncService := filesync.New()
personalSpaceIdGetter := &personalSpaceIdStub{personalSpaceId: spaceId}
spaceIdResolver := &spaceResolverStub{spaceId: spaceId}
objectStore := objectstore.NewStoreFixture(t)
eventSender := mock_event.NewMockSender(t)
ctx := context.Background()
@ -83,8 +57,6 @@ func newFixture(t *testing.T) *fixture {
a.Register(testutil.PrepareMock(ctx, a, eventSender))
a.Register(blockStorage)
a.Register(objectStore)
a.Register(personalSpaceIdGetter)
a.Register(spaceIdResolver)
a.Register(rpcStoreService)
err := a.Start(ctx)
require.NoError(t, err)
@ -103,6 +75,7 @@ func newFixture(t *testing.T) *fixture {
func TestFileAdd(t *testing.T) {
fx := newFixture(t)
ctx := context.Background()
uploaded := make(chan struct{})
fx.fileSyncService.OnUploaded(func(fileId domain.FileId) error {
@ -121,13 +94,16 @@ func TestFileAdd(t *testing.T) {
WithLastModifiedDate(lastModifiedDate.Unix()),
WithReader(buf),
}
got, err := fx.FileAdd(context.Background(), spaceId, opts...)
got, err := fx.FileAdd(ctx, spaceId, opts...)
require.NoError(t, err)
assert.NotEmpty(t, got.FileId)
got.Commit()
t.Run("want to decrypt file content", func(t *testing.T) {
reader, err := got.File.Reader(context.Background())
t.Run("expect decrypting content", func(t *testing.T) {
file, err := fx.FileByHash(ctx, domain.FullFileId{FileId: got.FileId, SpaceId: spaceId})
require.NoError(t, err)
reader, err := file.Reader(ctx)
require.NoError(t, err)
gotContent, err := io.ReadAll(reader)
@ -136,20 +112,23 @@ func TestFileAdd(t *testing.T) {
})
t.Run("want to store encrypted content in DAG", func(t *testing.T) {
encryptedContent, err := fx.commonFileService.GetFile(context.Background(), cid.MustParse(got.File.Info().Hash))
t.Run("expect that encrypted content stored in DAG", func(t *testing.T) {
file, err := fx.FileByHash(ctx, domain.FullFileId{FileId: got.FileId, SpaceId: spaceId})
require.NoError(t, err)
contentCid := cid.MustParse(file.Info().Hash)
encryptedContent, err := fx.commonFileService.GetFile(ctx, contentCid)
require.NoError(t, err)
gotEncryptedContent, err := io.ReadAll(encryptedContent)
require.NoError(t, err)
assert.NotEqual(t, fileContent, string(gotEncryptedContent))
})
t.Run("check that file is uploaded to backup node", func(t *testing.T) {
err = fx.fileSyncService.AddFile(spaceId, got.FileId, true, false)
require.NoError(t, err)
<-uploaded
infos, err := fx.rpcStore.FilesInfo(context.Background(), spaceId, got.FileId)
infos, err := fx.rpcStore.FilesInfo(ctx, spaceId, got.FileId)
require.NoError(t, err)
require.Len(t, infos, 1)
@ -157,3 +136,56 @@ func TestFileAdd(t *testing.T) {
assert.Equal(t, got.FileId.String(), infos[0].FileId)
})
}
func TestAddFilesConcurrently(t *testing.T) {
testAddConcurrently(t, func(t *testing.T, fx *fixture) *AddResult {
return testAddFile(t, fx)
})
}
func testAddConcurrently(t *testing.T, addFunc func(t *testing.T, fx *fixture) *AddResult) {
fx := newFixture(t)
const numTimes = 5
gotCh := make(chan *AddResult, numTimes)
for i := 0; i < numTimes; i++ {
go func() {
got := addFunc(t, fx)
gotCh <- got
}()
}
var prev *AddResult
for i := 0; i < numTimes; i++ {
got := <-gotCh
if prev == nil {
// The first file should be new
assert.False(t, got.IsExisting)
prev = got
} else {
assert.Equal(t, prev.FileId, got.FileId)
assert.Equal(t, prev.EncryptionKeys, got.EncryptionKeys)
assert.Equal(t, prev.MIME, got.MIME)
assert.Equal(t, prev.Size, got.Size)
assert.True(t, got.IsExisting)
}
}
}
func testAddFile(t *testing.T, fx *fixture) *AddResult {
fileName := "myFile"
lastModifiedDate := time.Now()
fileContent := "it's my favorite file"
buf := strings.NewReader(fileContent)
opts := []AddOption{
WithName(fileName),
WithLastModifiedDate(lastModifiedDate.Unix()),
WithReader(buf),
}
got, err := fx.FileAdd(context.Background(), spaceId, opts...)
require.NoError(t, err)
got.Commit()
return got
}

73
core/files/fileuploader/uploader.go
View file

@ -224,9 +224,15 @@ func (u *uploader) SetAdditionalDetails(details *types.Struct) Uploader {
func (u *uploader) SetBytes(b []byte) Uploader {
u.getReader = func(_ context.Context) (*fileReader, error) {
buf := bytes.NewReader(b)
bufReaderSize := bufio.NewReaderSize(buf, bufSize)
return &fileReader{
bufioSeekClose: &bufioSeekClose{
Reader: bufio.NewReaderSize(bytes.NewReader(b), bufSize),
Reader: bufReaderSize,
seek: func(offset int64, whence int) (int64, error) {
bufReaderSize.Reset(buf)
return buf.Seek(offset, whence)
},
},
}, nil
}
@ -419,9 +425,9 @@ func (u *uploader) Upload(ctx context.Context) (result UploadResult) {
opts = append(opts, u.opts...)
}
var addResult *addToStorageResult
var addResult *files.AddResult
if u.fileType == model.BlockContentFile_Image {
addResult, err = u.addImageToStorage(ctx, opts)
addResult, err = u.fileService.ImageAdd(ctx, u.spaceId, opts...)
if errors.Is(err, image.ErrFormat) || errors.Is(err, mill.ErrFormatSupportNotEnabled) {
return u.SetType(model.BlockContentFile_File).Upload(ctx)
}
@ -429,13 +435,15 @@ func (u *uploader) Upload(ctx context.Context) (result UploadResult) {
return UploadResult{Err: fmt.Errorf("add image to storage: %w", err)}
}
} else {
addResult, err = u.addFileToStorage(ctx, opts)
addResult, err = u.fileService.FileAdd(ctx, u.spaceId, opts...)
if err != nil {
return UploadResult{Err: fmt.Errorf("add file to storage: %w", err)}
}
}
result.MIME = addResult.mime
result.Size = addResult.size
defer addResult.Commit()
result.MIME = addResult.MIME
result.Size = addResult.Size
fileObjectId, fileObjectDetails, err := u.getOrCreateFileObject(ctx, addResult)
if err != nil {
@ -459,54 +467,11 @@ func (u *uploader) Upload(ctx context.Context) (result UploadResult) {
return
}
type addToStorageResult struct {
fileId domain.FileId
fileKeys *domain.FileEncryptionKeys
fileExists bool
mime string
size int64
}
func (u *uploader) addImageToStorage(ctx context.Context, addOptions []files.AddOption) (*addToStorageResult, error) {
addResult, err := u.fileService.ImageAdd(ctx, u.spaceId, addOptions...)
if err != nil {
return nil, err
}
res := &addToStorageResult{
fileId: addResult.FileId,
fileKeys: addResult.EncryptionKeys,
fileExists: addResult.IsExisting,
}
orig, _ := addResult.Image.GetOriginalFile(ctx)
if orig != nil {
res.mime = orig.Meta().Media
res.size = orig.Meta().Size
}
return res, nil
}
func (u *uploader) addFileToStorage(ctx context.Context, addOptions []files.AddOption) (*addToStorageResult, error) {
addResult, err := u.fileService.FileAdd(ctx, u.spaceId, addOptions...)
if err != nil {
return nil, err
}
res := &addToStorageResult{
fileId: addResult.FileId,
fileKeys: addResult.EncryptionKeys,
fileExists: addResult.IsExisting,
}
if meta := addResult.File.Meta(); meta != nil {
res.mime = meta.Media
res.size = meta.Size
}
return res, nil
}
func (u *uploader) getOrCreateFileObject(ctx context.Context, addResult *addToStorageResult) (string, *types.Struct, error) {
if addResult.fileExists {
func (u *uploader) getOrCreateFileObject(ctx context.Context, addResult *files.AddResult) (string, *types.Struct, error) {
if addResult.IsExisting {
id, details, err := u.fileObjectService.GetObjectDetailsByFileId(domain.FullFileId{
SpaceId: u.spaceId,
FileId: addResult.fileId,
FileId: addResult.FileId,
})
if err == nil {
return id, details, nil
@ -520,8 +485,8 @@ func (u *uploader) getOrCreateFileObject(ctx context.Context, addResult *addToSt
}
fileObjectId, fileObjectDetails, err := u.fileObjectService.Create(ctx, u.spaceId, fileobject.CreateRequest{
FileId: addResult.fileId,
EncryptionKeys: addResult.fileKeys.EncryptionKeys,
FileId: addResult.FileId,
EncryptionKeys: addResult.EncryptionKeys.EncryptionKeys,
ObjectOrigin: u.origin,
AdditionalDetails: u.additionalDetails,
})

109
core/files/fileuploader/uploader_test.go
View file

@ -2,11 +2,13 @@ package fileuploader
import (
"context"
"io"
"net/http"
"net/http/httptest"
"testing"
"time"
"github.com/anyproto/any-sync/app"
"github.com/anyproto/any-sync/commonfile/fileservice"
"github.com/gogo/protobuf/types"
"github.com/magiconair/properties/assert"
"github.com/stretchr/testify/mock"
@ -18,10 +20,20 @@ import (
file2 "github.com/anyproto/anytype-heart/core/block/simple/file"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/core/domain/objectorigin"
"github.com/anyproto/anytype-heart/core/event/mock_event"
"github.com/anyproto/anytype-heart/core/files"
"github.com/anyproto/anytype-heart/core/files/fileobject/mock_fileobject"
"github.com/anyproto/anytype-heart/core/filestorage"
"github.com/anyproto/anytype-heart/core/filestorage/filesync"
"github.com/anyproto/anytype-heart/core/filestorage/rpcstore"
"github.com/anyproto/anytype-heart/pkg/lib/bundle"
"github.com/anyproto/anytype-heart/pkg/lib/core"
"github.com/anyproto/anytype-heart/pkg/lib/datastore"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/filestore"
"github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
"github.com/anyproto/anytype-heart/tests/testutil"
"github.com/anyproto/anytype-heart/util/pbtypes"
"github.com/anyproto/anytype-heart/util/testMock"
)
@ -40,7 +52,6 @@ func TestUploader_Upload(t *testing.T) {
fx := newFixture(t)
defer fx.tearDown()
fx.expectImageAdd()
fileObjectId := fx.expectCreateObject()
b := newBlock(model.BlockContentFile_Image)
@ -49,13 +60,12 @@ func TestUploader_Upload(t *testing.T) {
assert.Equal(t, res.FileObjectId, fileObjectId)
assert.Equal(t, res.Name, "unnamed.jpg")
assert.Equal(t, b.Model().GetFile().Name, "unnamed.jpg")
assert.Equal(t, res.MIME, "image/jpg")
assert.Equal(t, res.MIME, "image/jpeg")
})
t.Run("image type detect", func(t *testing.T) {
fx := newFixture(t)
defer fx.tearDown()
fx.expectImageAdd()
fx.expectCreateObject()
res := fx.Uploader.AutoType(true).SetFile("./testdata/unnamed.jpg").Upload(ctx)
@ -65,7 +75,6 @@ func TestUploader_Upload(t *testing.T) {
fx := newFixture(t)
defer fx.tearDown()
fx.expectFileAdd()
fileObjectId := fx.expectCreateObject()
b := newBlock(model.BlockContentFile_Image)
@ -87,7 +96,6 @@ func TestUploader_Upload(t *testing.T) {
serv := httptest.NewServer(mux)
defer serv.Close()
fx.expectImageAdd()
fileObjectId := fx.expectCreateObject()
res := fx.Uploader.AutoType(true).SetUrl(serv.URL + "/unnamed.jpg").Upload(ctx)
@ -110,7 +118,6 @@ func TestUploader_Upload(t *testing.T) {
serv := httptest.NewServer(mux)
defer serv.Close()
fx.expectImageAdd()
fileObjectId := fx.expectCreateObject()
res := fx.Uploader.AutoType(true).SetUrl(serv.URL + "/unnamed.jpg").Upload(ctx)
@ -132,7 +139,6 @@ func TestUploader_Upload(t *testing.T) {
serv := httptest.NewServer(mux)
defer serv.Close()
fx.expectImageAdd()
fileObjectId := fx.expectCreateObject()
res := fx.Uploader.AutoType(true).SetUrl(serv.URL + "/unnamed.jpg?text=text").Upload(ctx)
@ -147,23 +153,67 @@ func TestUploader_Upload(t *testing.T) {
fx := newFixture(t)
defer fx.tearDown()
fx.expectFileAdd()
fileObjectId := fx.expectCreateObject()
res := fx.Uploader.SetBytes([]byte("my bytes")).SetName("filename").Upload(ctx)
inputContent := "my bytes"
res := fx.Uploader.SetBytes([]byte(inputContent)).SetName("filename").Upload(ctx)
require.NoError(t, res.Err)
assert.Equal(t, res.FileObjectId, fileObjectId)
assert.Equal(t, res.Name, "filename")
fileId := domain.FileId(pbtypes.GetString(res.FileObjectDetails, bundle.RelationKeyFileId.String()))
file, err := fx.fileService.FileByHash(ctx, domain.FullFileId{FileId: fileId, SpaceId: "space1"})
require.NoError(t, err)
reader, err := file.Reader(ctx)
require.NoError(t, err)
gotContent, err := io.ReadAll(reader)
require.NoError(t, err)
assert.Equal(t, inputContent, string(gotContent))
})
}
func newFileServiceFixture(t *testing.T) files.Service {
dataStoreProvider := datastore.NewInMemory()
blockStorage := filestorage.NewInMemory()
rpcStore := rpcstore.NewInMemoryStore(1024)
rpcStoreService := rpcstore.NewInMemoryService(rpcStore)
commonFileService := fileservice.New()
fileSyncService := filesync.New()
objectStore := objectstore.NewStoreFixture(t)
eventSender := mock_event.NewMockSender(t)
ctx := context.Background()
a := new(app.App)
a.Register(dataStoreProvider)
a.Register(filestore.New())
a.Register(commonFileService)
a.Register(fileSyncService)
a.Register(testutil.PrepareMock(ctx, a, eventSender))
a.Register(blockStorage)
a.Register(objectStore)
a.Register(rpcStoreService)
err := a.Start(ctx)
require.NoError(t, err)
s := files.New()
err = s.Init(a)
require.NoError(t, err)
return s
}
func newFixture(t *testing.T) *uplFixture {
picker := mock_getblock.NewMockObjectGetter(t)
fx := &uplFixture{
ctrl: gomock.NewController(t),
picker: picker,
}
fx.fileService = testMock.NewMockFileService(fx.ctrl)
fx.fileService = newFileServiceFixture(t)
fx.fileObjectService = mock_fileobject.NewMockService(t)
uploaderProvider := &service{
@ -173,15 +223,12 @@ func newFixture(t *testing.T) *uplFixture {
fileObjectService: fx.fileObjectService,
}
fx.Uploader = uploaderProvider.NewUploader("space1", objectorigin.None())
fx.file = testMock.NewMockFile(fx.ctrl)
fx.file.EXPECT().FileId().Return(domain.FileId("123")).AnyTimes()
return fx
}
type uplFixture struct {
Uploader
file *testMock.MockFile
fileService *testMock.MockFileService
fileService files.Service
ctrl *gomock.Controller
picker *mock_getblock.MockObjectGetter
fileObjectService *mock_fileobject.MockService
@ -204,38 +251,6 @@ func (fx *uplFixture) tearDown() {
fx.ctrl.Finish()
}
func (fx *uplFixture) expectImageAdd() {
im := fx.newImage("123")
fx.fileService.EXPECT().ImageAdd(gomock.Any(), gomock.Any(), gomock.Any()).Return(&files.ImageAddResult{
FileId: "123",
Image: im,
EncryptionKeys: &domain.FileEncryptionKeys{
FileId: "123",
EncryptionKeys: map[string]string{},
},
}, nil)
im.EXPECT().GetOriginalFile(gomock.Any()).Return(fx.file, nil)
fx.file.EXPECT().Meta().Return(&files.FileMeta{Media: "image/jpg"}).AnyTimes()
}
func (fx *uplFixture) expectFileAdd() {
meta := &files.FileMeta{
Media: "text/text",
Name: "test.txt",
Size: 3,
Added: time.Now(),
}
file := fx.newFile("123", meta)
fx.fileService.EXPECT().FileAdd(gomock.Any(), gomock.Any(), gomock.Any()).Return(&files.FileAddResult{
FileId: "123",
File: file,
EncryptionKeys: &domain.FileEncryptionKeys{
FileId: "123",
EncryptionKeys: map[string]string{},
},
}, nil)
}
func (fx *uplFixture) expectCreateObject() string {
fileObjectId := "fileObjectId1"
fx.fileObjectService.EXPECT().Create(mock.Anything, mock.Anything, mock.Anything).Return(fileObjectId, &types.Struct{Fields: map[string]*types.Value{}}, nil)

88
core/files/images.go
View file

@ -5,6 +5,7 @@ import (
"errors"
"fmt"
"io"
"sync"
uio "github.com/ipfs/boxo/ipld/unixfs/io"
ipld "github.com/ipfs/go-ipld-format"
@ -49,34 +50,39 @@ func (s *service) ImageByHash(ctx context.Context, id domain.FullFileId) (Image,
}, nil
}
type ImageAddResult struct {
FileId domain.FileId
Image Image
EncryptionKeys *domain.FileEncryptionKeys
IsExisting bool
}
func (s *service) ImageAdd(ctx context.Context, spaceId string, options ...AddOption) (*ImageAddResult, error) {
func (s *service) ImageAdd(ctx context.Context, spaceId string, options ...AddOption) (*AddResult, error) {
opts := AddOptions{}
for _, opt := range options {
opt(&opts)
}
err := s.normalizeOptions(ctx, spaceId, &opts)
err := s.normalizeOptions(&opts)
if err != nil {
return nil, err
}
addLock := s.lockAddOperation(opts.checksum)
dirEntries, err := s.addImageNodes(ctx, spaceId, opts.Reader, opts.Name)
if errors.Is(err, errFileExists) {
return s.newExisingImageResult(spaceId, dirEntries)
res, err := s.newExisingImageResult(addLock, dirEntries)
if err != nil {
addLock.Unlock()
return nil, err
}
return res, nil
}
if err != nil {
addLock.Unlock()
return nil, err
}
if len(dirEntries) == 0 {
addLock.Unlock()
return nil, errors.New("no image variants")
}
rootNode, keys, err := s.addImageRootNode(ctx, spaceId, dirEntries)
if err != nil {
addLock.Unlock()
return nil, err
}
fileId := domain.FileId(rootNode.Cid().String())
@ -86,6 +92,7 @@ func (s *service) ImageAdd(ctx context.Context, spaceId string, options ...AddOp
}
err = s.fileStore.AddFileKeys(fileKeys)
if err != nil {
addLock.Unlock()
return nil, fmt.Errorf("failed to save file keys: %w", err)
}
@ -93,19 +100,24 @@ func (s *service) ImageAdd(ctx context.Context, spaceId string, options ...AddOp
for _, variant := range dirEntries {
err = s.fileStore.LinkFileVariantToFile(id.FileId, domain.FileContentId(variant.fileInfo.Hash))
if err != nil {
addLock.Unlock()
return nil, fmt.Errorf("failed to link file variant to file: %w", err)
}
}
err = s.storeFileSize(spaceId, fileId)
if err != nil {
addLock.Unlock()
return nil, fmt.Errorf("store file size: %w", err)
}
return &ImageAddResult{
entry := dirEntries[0]
return &AddResult{
FileId: fileId,
Image: s.newImage(spaceId, fileId, dirEntries),
MIME: entry.fileInfo.Media,
Size: entry.fileInfo.Size_,
EncryptionKeys: &fileKeys,
lock: addLock,
}, nil
}
@ -115,7 +127,6 @@ func (s *service) addImageNodes(ctx context.Context, spaceID string, reader io.R
return nil, schema.ErrEmptySchema
}
var isExisting bool
dirEntries := make([]dirEntry, 0, len(sch.Links))
for _, link := range sch.Links {
stepMill, err := schema.GetMill(link.Mill, link.Opts)
@ -124,28 +135,37 @@ func (s *service) addImageNodes(ctx context.Context, spaceID string, reader io.R
}
opts := &AddOptions{
Reader: reader,
Use: "",
Media: "",
Name: filename,
}
err = s.normalizeOptions(ctx, spaceID, opts)
err = s.normalizeOptions(opts)
if err != nil {
return nil, err
}
added, fileNode, err := s.addFileNode(ctx, spaceID, stepMill, *opts)
if errors.Is(err, errFileExists) {
// If we found out that original variant is already exists, so we are trying to add the same file
// If we found out that original variant is already exists, so we are trying to add the same file.
if link.Name == "original" {
isExisting = true
return []dirEntry{
{
name: link.Name,
fileInfo: added,
},
}, errFileExists
} else {
// If we have multiple variants with the same hash, for example "original" and "large",
// we need to find the previously added file node
var found bool
for _, entry := range dirEntries {
if entry.fileInfo.Hash == added.Hash {
fileNode = entry.fileNode
found = true
break
}
}
if !found {
return nil, fmt.Errorf("handling existing variant: failed to find file node for %s", link.Name)
}
}
} else if err != nil {
return nil, err
@ -157,10 +177,6 @@ func (s *service) addImageNodes(ctx context.Context, spaceID string, reader io.R
})
reader.Seek(0, 0)
}
if isExisting {
return dirEntries, errFileExists
}
return dirEntries, nil
}
@ -220,20 +236,24 @@ func (s *service) addImageRootNode(ctx context.Context, spaceID string, dirEntri
return outerNode, keys, nil
}
func (s *service) newExisingImageResult(spaceId string, dirEntries []dirEntry) (*ImageAddResult, error) {
for _, entry := range dirEntries {
fileId, keys, err := s.getFileIdAndEncryptionKeysFromInfo(entry.fileInfo)
if err != nil {
return nil, err
}
return &ImageAddResult{
IsExisting: true,
FileId: fileId,
Image: s.newImage(spaceId, fileId, dirEntries),
EncryptionKeys: keys,
}, nil
func (s *service) newExisingImageResult(lock *sync.Mutex, dirEntries []dirEntry) (*AddResult, error) {
if len(dirEntries) == 0 {
return nil, errors.New("no image variants")
}
return nil, errors.New("image directory is empty")
entry := dirEntries[0]
fileId, keys, err := s.getFileIdAndEncryptionKeysFromInfo(entry.fileInfo)
if err != nil {
return nil, err
}
return &AddResult{
IsExisting: true,
FileId: fileId,
MIME: entry.fileInfo.Media,
Size: entry.fileInfo.Size_,
EncryptionKeys: keys,
lock: lock,
}, nil
}
func newVariantsByWidth(dirEntries []dirEntry) map[int]*storage.FileInfo {

60
core/files/images_test.go Normal file
View file

@ -0,0 +1,60 @@
package files
import (
"context"
"os"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestImageAdd(t *testing.T) {
t.Run("add image", func(t *testing.T) {
fx := newFixture(t)
got := testAddImage(t, fx)
assert.NotEmpty(t, got.MIME)
assert.True(t, got.Size > 0)
assert.False(t, got.IsExisting)
t.Run("add same image again", func(t *testing.T) {
got2 := testAddImage(t, fx)
assert.NotEmpty(t, got2.MIME)
assert.True(t, got2.Size > 0)
assert.Equal(t, got.FileId, got2.FileId)
assert.Equal(t, got.EncryptionKeys, got2.EncryptionKeys)
assert.Equal(t, got.MIME, got2.MIME)
assert.Equal(t, got.Size, got2.Size)
assert.True(t, got2.IsExisting)
})
})
// We had a problem with concurrent adding of the same image, so test it
t.Run("concurrent adding of the same image", func(t *testing.T) {
testAddConcurrently(t, func(t *testing.T, fx *fixture) *AddResult {
return testAddImage(t, fx)
})
})
}
func testAddImage(t *testing.T, fx *fixture) *AddResult {
f, err := os.Open("../../pkg/lib/mill/testdata/image.jpeg")
require.NoError(t, err)
defer f.Close()
fileName := "myFile"
lastModifiedDate := time.Now()
opts := []AddOption{
WithName(fileName),
WithLastModifiedDate(lastModifiedDate.Unix()),
WithReader(f),
}
got, err := fx.ImageAdd(context.Background(), spaceId, opts...)
require.NoError(t, err)
got.Commit()
return got
}

28
core/files/mock_files/mock_Service.go
View file

@ -30,7 +30,7 @@ func (_m *MockService) EXPECT() *MockService_Expecter {
}
// FileAdd provides a mock function with given fields: ctx, spaceID, options
func (_m *MockService) FileAdd(ctx context.Context, spaceID string, options ...files.AddOption) (*files.FileAddResult, error) {
func (_m *MockService) FileAdd(ctx context.Context, spaceID string, options ...files.AddOption) (*files.AddResult, error) {
_va := make([]interface{}, len(options))
for _i := range options {
_va[_i] = options[_i]
@ -44,16 +44,16 @@ func (_m *MockService) FileAdd(ctx context.Context, spaceID string, options ...f
panic("no return value specified for FileAdd")
}
var r0 *files.FileAddResult
var r0 *files.AddResult
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, ...files.AddOption) (*files.FileAddResult, error)); ok {
if rf, ok := ret.Get(0).(func(context.Context, string, ...files.AddOption) (*files.AddResult, error)); ok {
return rf(ctx, spaceID, options...)
}
if rf, ok := ret.Get(0).(func(context.Context, string, ...files.AddOption) *files.FileAddResult); ok {
if rf, ok := ret.Get(0).(func(context.Context, string, ...files.AddOption) *files.AddResult); ok {
r0 = rf(ctx, spaceID, options...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*files.FileAddResult)
r0 = ret.Get(0).(*files.AddResult)
}
}
@ -93,12 +93,12 @@ func (_c *MockService_FileAdd_Call) Run(run func(ctx context.Context, spaceID st
return _c
}
func (_c *MockService_FileAdd_Call) Return(_a0 *files.FileAddResult, _a1 error) *MockService_FileAdd_Call {
func (_c *MockService_FileAdd_Call) Return(_a0 *files.AddResult, _a1 error) *MockService_FileAdd_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockService_FileAdd_Call) RunAndReturn(run func(context.Context, string, ...files.AddOption) (*files.FileAddResult, error)) *MockService_FileAdd_Call {
func (_c *MockService_FileAdd_Call) RunAndReturn(run func(context.Context, string, ...files.AddOption) (*files.AddResult, error)) *MockService_FileAdd_Call {
_c.Call.Return(run)
return _c
}
@ -395,7 +395,7 @@ func (_c *MockService_GetSpaceUsage_Call) RunAndReturn(run func(context.Context,
}
// ImageAdd provides a mock function with given fields: ctx, spaceID, options
func (_m *MockService) ImageAdd(ctx context.Context, spaceID string, options ...files.AddOption) (*files.ImageAddResult, error) {
func (_m *MockService) ImageAdd(ctx context.Context, spaceID string, options ...files.AddOption) (*files.AddResult, error) {
_va := make([]interface{}, len(options))
for _i := range options {
_va[_i] = options[_i]
@ -409,16 +409,16 @@ func (_m *MockService) ImageAdd(ctx context.Context, spaceID string, options ...
panic("no return value specified for ImageAdd")
}
var r0 *files.ImageAddResult
var r0 *files.AddResult
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, ...files.AddOption) (*files.ImageAddResult, error)); ok {
if rf, ok := ret.Get(0).(func(context.Context, string, ...files.AddOption) (*files.AddResult, error)); ok {
return rf(ctx, spaceID, options...)
}
if rf, ok := ret.Get(0).(func(context.Context, string, ...files.AddOption) *files.ImageAddResult); ok {
if rf, ok := ret.Get(0).(func(context.Context, string, ...files.AddOption) *files.AddResult); ok {
r0 = rf(ctx, spaceID, options...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*files.ImageAddResult)
r0 = ret.Get(0).(*files.AddResult)
}
}
@ -458,12 +458,12 @@ func (_c *MockService_ImageAdd_Call) Run(run func(ctx context.Context, spaceID s
return _c
}
func (_c *MockService_ImageAdd_Call) Return(_a0 *files.ImageAddResult, _a1 error) *MockService_ImageAdd_Call {
func (_c *MockService_ImageAdd_Call) Return(_a0 *files.AddResult, _a1 error) *MockService_ImageAdd_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockService_ImageAdd_Call) RunAndReturn(run func(context.Context, string, ...files.AddOption) (*files.ImageAddResult, error)) *MockService_ImageAdd_Call {
func (_c *MockService_ImageAdd_Call) RunAndReturn(run func(context.Context, string, ...files.AddOption) (*files.AddResult, error)) *MockService_ImageAdd_Call {
_c.Call.Return(run)
return _c
}

38
core/files/options.go
View file

@ -1,28 +1,24 @@
package files
import (
"context"
"fmt"
"io"
"io/ioutil"
"net/http"
"strings"
"github.com/h2non/filetype"
ipfspath "github.com/ipfs/boxo/path"
"github.com/anyproto/anytype-heart/core/domain"
"github.com/anyproto/anytype-heart/pkg/lib/pb/storage"
)
type AddOption func(*AddOptions)
type AddOptions struct {
Reader io.ReadSeeker
Use string
Media string
Name string
LastModifiedDate int64
// checksum of original file, calculated from Reader
checksum string
}
func WithReader(r io.ReadSeeker) AddOption {
@ -43,30 +39,16 @@ func WithLastModifiedDate(timestamp int64) AddOption {
}
}
func (s *service) normalizeOptions(ctx context.Context, spaceID string, opts *AddOptions) error {
if opts.Use != "" {
ref, err := ipfspath.ParsePath(opts.Use)
func (s *service) normalizeOptions(opts *AddOptions) error {
if opts.checksum == "" && opts.Reader != nil {
var err error
opts.checksum, err = checksum(opts.Reader, false)
if err != nil {
return err
return fmt.Errorf("failed to calculate checksum: %w", err)
}
parts := strings.Split(ref.String(), "/")
hash := parts[len(parts)-1]
var file *storage.FileInfo
opts.Reader, file, err = s.fileContent(ctx, spaceID, domain.FileContentId(hash))
_, err = opts.Reader.Seek(0, io.SeekStart)
if err != nil {
/*if err == localstore.ErrNotFound{
// just cat the data from dagService
b, err := ipfsutil.DataAtCid(s.dagService, ref.String())
if err != nil {
return nil, err
}
reader = bytes.NewReader(b)
conf.Use = ref.String()
} else {*/
return err
} else {
opts.Use = file.Checksum
return fmt.Errorf("failed to seek reader: %w", err)
}
}

14
core/filestorage/filesync/filestore_mock.go
View file

@ -386,6 +386,20 @@ func (mr *MockFileStoreMockRecorder) SetChunksCount(arg0, arg1 any) *gomock.Call
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChunksCount", reflect.TypeOf((*MockFileStore)(nil).SetChunksCount), arg0, arg1)
}
// SetFileOrigin mocks base method.
func (m *MockFileStore) SetFileOrigin(arg0 domain.FileId, arg1 objectorigin.ObjectOrigin) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetFileOrigin", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// SetFileOrigin indicates an expected call of SetFileOrigin.
func (mr *MockFileStoreMockRecorder) SetFileOrigin(arg0, arg1 any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFileOrigin", reflect.TypeOf((*MockFileStore)(nil).SetFileOrigin), arg0, arg1)
}
// SetFileSize mocks base method.
func (m *MockFileStore) SetFileSize(arg0 domain.FileId, arg1 int) error {
m.ctrl.T.Helper()

32
core/filestorage/filesync/filesync.go
View file

@ -57,29 +57,24 @@ type QueueInfo struct {
RemovingQueue []*QueueItem
}
type personalSpaceIDGetter interface {
PersonalSpaceID() string
}
type SyncStatus struct {
QueueLen int
}
type fileSync struct {
dbProvider datastore.Datastore
rpcStore rpcstore.RpcStore
queue *fileSyncStore
loopCtx context.Context
loopCancel context.CancelFunc
uploadPingCh chan struct{}
removePingCh chan struct{}
dagService ipld.DAGService
fileStore filestore.FileStore
eventSender event.Sender
onUploaded func(fileId domain.FileId) error
onUploadStarted func(fileId domain.FileId) error
onLimited func(fileId domain.FileId) error
personalIDGetter personalSpaceIDGetter
dbProvider datastore.Datastore
rpcStore rpcstore.RpcStore
queue *fileSyncStore
loopCtx context.Context
loopCancel context.CancelFunc
uploadPingCh chan struct{}
removePingCh chan struct{}
dagService ipld.DAGService
fileStore filestore.FileStore
eventSender event.Sender
onUploaded func(fileId domain.FileId) error
onUploadStarted func(fileId domain.FileId) error
onLimited func(fileId domain.FileId) error
importEventsMutex sync.Mutex
importEvents []*pb.Event
@ -94,7 +89,6 @@ func (f *fileSync) Init(a *app.App) (err error) {
f.rpcStore = a.MustComponent(rpcstore.CName).(rpcstore.Service).NewStore()
f.dagService = a.MustComponent(fileservice.CName).(fileservice.FileService).DAGService()
f.fileStore = app.MustComponent[filestore.FileStore](a)
f.personalIDGetter = app.MustComponent[personalSpaceIDGetter](a)
f.eventSender = app.MustComponent[event.Sender](a)
f.removePingCh = make(chan struct{})
f.uploadPingCh = make(chan struct{})

13
core/filestorage/filesync/filesync_test.go
View file

@ -159,16 +159,6 @@ func TestFileSync_RemoveFile(t *testing.T) {
fx.waitEmptyQueue(t, time.Second*5)
}
type personalSpaceIdStub struct {
personalSpaceId string
}
func (s *personalSpaceIdStub) Name() string { return "personalSpaceIdStub" }
func (s *personalSpaceIdStub) Init(a *app.App) error { return nil }
func (s *personalSpaceIdStub) PersonalSpaceID() string {
return s.personalSpaceId
}
func newFixture(t *testing.T, limit int) *fixture {
fx := &fixture{
FileSync: New(),
@ -184,8 +174,6 @@ func newFixture(t *testing.T, limit int) *fixture {
fileStoreMock.EXPECT().Close(gomock.Any()).AnyTimes()
fx.fileStoreMock = fileStoreMock
personalSpaceIdGetter := &personalSpaceIdStub{personalSpaceId: "space1"}
sender := mock_event.NewMockSender(t)
sender.EXPECT().Name().Return("event")
sender.EXPECT().Init(mock.Anything).Return(nil)
@ -205,7 +193,6 @@ func newFixture(t *testing.T, limit int) *fixture {
Register(rpcstore.NewInMemoryService(fx.rpcStore)).
Register(fx.FileSync).
Register(fileStoreMock).
Register(personalSpaceIdGetter).
Register(sender)
require.NoError(t, fx.a.Start(ctx))
return fx

59
core/gallery/gallery.go
View file

@ -15,15 +15,25 @@ import (
"golang.org/x/net/html"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
"github.com/anyproto/anytype-heart/util/uri"
)
const timeout = time.Second * 30
const (
timeout = time.Second * 30
indexURI = "https://tools.gallery.any.coop/index.json"
)
type schemaResponse struct {
Schema string `json:"$schema"`
}
var (
ErrUnmarshalJson = fmt.Errorf("failed to unmarshall json")
ErrDownloadIndex = fmt.Errorf("failed to download gallery index")
)
// whitelist maps allowed hosts to regular expressions of URL paths
var whitelist = map[string]*regexp.Regexp{
"raw.githubusercontent.com": regexp.MustCompile(`^/anyproto.*`),
@ -35,14 +45,14 @@ var whitelist = map[string]*regexp.Regexp{
"storage.gallery.any.coop": regexp.MustCompile(`.*`),
}
func DownloadManifest(url string, checkWhitelist bool) (info *pb.RpcDownloadManifestResponseManifestInfo, err error) {
func DownloadManifest(url string, checkWhitelist bool) (info *model.ManifestInfo, err error) {
if err = uri.ValidateURI(url); err != nil {
return nil, fmt.Errorf("provided URL is not valid: %w", err)
}
if checkWhitelist && !IsInWhitelist(url) {
return nil, fmt.Errorf("URL '%s' is not in whitelist", url)
}
raw, err := getRawManifest(url)
raw, err := getRawJson(url)
if err != nil {
return nil, err
}
@ -72,6 +82,43 @@ func DownloadManifest(url string, checkWhitelist bool) (info *pb.RpcDownloadMani
return info, nil
}
func DownloadGalleryIndex() (*pb.RpcGalleryDownloadIndexResponse, error) {
raw, err := getRawJson(indexURI)
if err != nil {
return nil, fmt.Errorf("%w: %w", ErrDownloadIndex, err)
}
manifests := struct {
Experiences map[string]*model.ManifestInfo `json:"experiences"`
}{}
err = json.Unmarshal(raw, &manifests)
if err != nil {
return nil, fmt.Errorf("%w to get list of manifests from gallery index: %w", ErrUnmarshalJson, err)
}
response := &pb.RpcGalleryDownloadIndexResponse{}
for _, manifest := range manifests.Experiences {
response.Experiences = append(response.Experiences, manifest)
}
categories := struct {
Categories map[string][]string `json:"categories"`
}{}
err = json.Unmarshal(raw, &categories)
if err != nil {
return nil, fmt.Errorf("%w to get list of categories from gallery index: %w", ErrUnmarshalJson, err)
}
for name, experiences := range categories.Categories {
response.Categories = append(response.Categories, &pb.RpcGalleryDownloadIndexResponseCategory{
Name: name,
Experiences: experiences,
})
}
return response, nil
}
func IsInWhitelist(url string) bool {
if len(whitelist) == 0 {
return true
@ -88,7 +135,7 @@ func IsInWhitelist(url string) bool {
return false
}
func getRawManifest(url string) ([]byte, error) {
func getRawJson(url string) ([]byte, error) {
client := http.Client{Timeout: timeout}
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
@ -101,7 +148,7 @@ func getRawManifest(url string) ([]byte, error) {
}
if res.StatusCode != http.StatusOK {
return nil, fmt.Errorf("failed to get manifest. Status: %s", res.Status)
return nil, fmt.Errorf("failed to get json file. Status: %s", res.Status)
}
if res.Body != nil {
@ -115,7 +162,7 @@ func getRawManifest(url string) ([]byte, error) {
return body, nil
}
func validateSchema(schemaResp schemaResponse, info *pb.RpcDownloadManifestResponseManifestInfo) (err error) {
func validateSchema(schemaResp schemaResponse, info *model.ManifestInfo) (err error) {
if schemaResp.Schema == "" {
return
}

6
core/gallery/gallery_test.go
View file

@ -8,7 +8,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/anyproto/anytype-heart/pb"
"github.com/anyproto/anytype-heart/pkg/lib/pb/model"
)
const port = ":7070"
@ -133,8 +133,8 @@ func startHttpServer() *http.Server {
return server
}
func buildInfo() *pb.RpcDownloadManifestResponseManifestInfo {
return &pb.RpcDownloadManifestResponseManifestInfo{
func buildInfo() *model.ManifestInfo {
return &model.ManifestInfo{
Id: "id",
Name: "name",
Author: "https://github.com/anyproto",

8
core/subscription/collection.go
View file

@ -161,7 +161,9 @@ func (c *collectionSub) close() {
c.sortedSub.close()
}
func (s *service) newCollectionSub(id string, collectionID string, keys []string, flt database.Filter, order database.Order, limit, offset int, disableDepSub bool) (*collectionSub, error) {
func (s *service) newCollectionSub(
id, collectionID string, keys, filterDepIds []string, flt database.Filter, order database.Order, limit, offset int, disableDepSub bool,
) (*collectionSub, error) {
obs, err := s.newCollectionObserver(collectionID, id)
if err != nil {
return nil, err
@ -174,6 +176,10 @@ func (s *service) newCollectionSub(id string, collectionID string, keys []string
ssub := s.newSortedSub(id, keys, flt, order, limit, offset)
ssub.disableDep = disableDepSub
if !ssub.disableDep {
ssub.forceSubIds = filterDepIds
}
sub := &collectionSub{
id: id,
collectionID: collectionID,

5
core/subscription/service.go
View file

@ -241,13 +241,10 @@ func queryEntries(objectStore objectstore.ObjectStore, f *database.Filters) ([]*
}
func (s *service) subscribeForCollection(req pb.RpcObjectSearchSubscribeRequest, f *database.Filters, filterDepIds []string) (*pb.RpcObjectSearchSubscribeResponse, error) {
sub, err := s.newCollectionSub(req.SubId, req.CollectionId, req.Keys, f.FilterObj, f.Order, int(req.Limit), int(req.Offset), req.NoDepSubscription)
sub, err := s.newCollectionSub(req.SubId, req.CollectionId, req.Keys, filterDepIds, f.FilterObj, f.Order, int(req.Limit), int(req.Offset), req.NoDepSubscription)
if err != nil {
return nil, err
}
if !sub.sortedSub.disableDep {
sub.sortedSub.forceSubIds = filterDepIds
}
if err := sub.init(nil); err != nil {
return nil, fmt.Errorf("subscription init error: %w", err)
}

312
docs/proto.md
View file

@ -547,11 +547,6 @@
- [Rpc.Debug.TreeHeads.Response](#anytype-Rpc-Debug-TreeHeads-Response)
- [Rpc.Debug.TreeHeads.Response.Error](#anytype-Rpc-Debug-TreeHeads-Response-Error)
- [Rpc.Debug.TreeInfo](#anytype-Rpc-Debug-TreeInfo)
- [Rpc.DownloadManifest](#anytype-Rpc-DownloadManifest)
- [Rpc.DownloadManifest.Request](#anytype-Rpc-DownloadManifest-Request)
- [Rpc.DownloadManifest.Response](#anytype-Rpc-DownloadManifest-Response)
- [Rpc.DownloadManifest.Response.Error](#anytype-Rpc-DownloadManifest-Response-Error)
- [Rpc.DownloadManifest.Response.ManifestInfo](#anytype-Rpc-DownloadManifest-Response-ManifestInfo)
- [Rpc.File](#anytype-Rpc-File)
- [Rpc.File.Download](#anytype-Rpc-File-Download)
- [Rpc.File.Download.Request](#anytype-Rpc-File-Download-Request)
@ -588,6 +583,16 @@
- [Rpc.File.Upload.Request](#anytype-Rpc-File-Upload-Request)
- [Rpc.File.Upload.Response](#anytype-Rpc-File-Upload-Response)
- [Rpc.File.Upload.Response.Error](#anytype-Rpc-File-Upload-Response-Error)
- [Rpc.Gallery](#anytype-Rpc-Gallery)
- [Rpc.Gallery.DownloadIndex](#anytype-Rpc-Gallery-DownloadIndex)
- [Rpc.Gallery.DownloadIndex.Request](#anytype-Rpc-Gallery-DownloadIndex-Request)
- [Rpc.Gallery.DownloadIndex.Response](#anytype-Rpc-Gallery-DownloadIndex-Response)
- [Rpc.Gallery.DownloadIndex.Response.Category](#anytype-Rpc-Gallery-DownloadIndex-Response-Category)
- [Rpc.Gallery.DownloadIndex.Response.Error](#anytype-Rpc-Gallery-DownloadIndex-Response-Error)
- [Rpc.Gallery.DownloadManifest](#anytype-Rpc-Gallery-DownloadManifest)
- [Rpc.Gallery.DownloadManifest.Request](#anytype-Rpc-Gallery-DownloadManifest-Request)
- [Rpc.Gallery.DownloadManifest.Response](#anytype-Rpc-Gallery-DownloadManifest-Response)
- [Rpc.Gallery.DownloadManifest.Response.Error](#anytype-Rpc-Gallery-DownloadManifest-Response-Error)
- [Rpc.GenericErrorResponse](#anytype-Rpc-GenericErrorResponse)
- [Rpc.GenericErrorResponse.Error](#anytype-Rpc-GenericErrorResponse-Error)
- [Rpc.History](#anytype-Rpc-History)
@ -1152,7 +1157,6 @@
- [Rpc.Debug.Subscriptions.Response.Error.Code](#anytype-Rpc-Debug-Subscriptions-Response-Error-Code)
- [Rpc.Debug.Tree.Response.Error.Code](#anytype-Rpc-Debug-Tree-Response-Error-Code)
- [Rpc.Debug.TreeHeads.Response.Error.Code](#anytype-Rpc-Debug-TreeHeads-Response-Error-Code)
- [Rpc.DownloadManifest.Response.Error.Code](#anytype-Rpc-DownloadManifest-Response-Error-Code)
- [Rpc.File.Download.Response.Error.Code](#anytype-Rpc-File-Download-Response-Error-Code)
- [Rpc.File.Drop.Response.Error.Code](#anytype-Rpc-File-Drop-Response-Error-Code)
- [Rpc.File.ListOffload.Response.Error.Code](#anytype-Rpc-File-ListOffload-Response-Error-Code)
@ -1161,6 +1165,8 @@
- [Rpc.File.SpaceOffload.Response.Error.Code](#anytype-Rpc-File-SpaceOffload-Response-Error-Code)
- [Rpc.File.SpaceUsage.Response.Error.Code](#anytype-Rpc-File-SpaceUsage-Response-Error-Code)
- [Rpc.File.Upload.Response.Error.Code](#anytype-Rpc-File-Upload-Response-Error-Code)
- [Rpc.Gallery.DownloadIndex.Response.Error.Code](#anytype-Rpc-Gallery-DownloadIndex-Response-Error-Code)
- [Rpc.Gallery.DownloadManifest.Response.Error.Code](#anytype-Rpc-Gallery-DownloadManifest-Response-Error-Code)
- [Rpc.GenericErrorResponse.Error.Code](#anytype-Rpc-GenericErrorResponse-Error-Code)
- [Rpc.History.GetVersions.Response.Error.Code](#anytype-Rpc-History-GetVersions-Response-Error-Code)
- [Rpc.History.SetVersion.Response.Error.Code](#anytype-Rpc-History-SetVersion-Response-Error-Code)
@ -1531,6 +1537,7 @@
- [InvitePayload](#anytype-model-InvitePayload)
- [Layout](#anytype-model-Layout)
- [LinkPreview](#anytype-model-LinkPreview)
- [ManifestInfo](#anytype-model-ManifestInfo)
- [Metadata](#anytype-model-Metadata)
- [Metadata.Payload](#anytype-model-Metadata-Payload)
- [Metadata.Payload.IdentityPayload](#anytype-model-Metadata-Payload-IdentityPayload)
@ -1750,7 +1757,8 @@
| LinkPreview | [Rpc.LinkPreview.Request](#anytype-Rpc-LinkPreview-Request) | [Rpc.LinkPreview.Response](#anytype-Rpc-LinkPreview-Response) | |
| UnsplashSearch | [Rpc.Unsplash.Search.Request](#anytype-Rpc-Unsplash-Search-Request) | [Rpc.Unsplash.Search.Response](#anytype-Rpc-Unsplash-Search-Response) | |
| UnsplashDownload | [Rpc.Unsplash.Download.Request](#anytype-Rpc-Unsplash-Download-Request) | [Rpc.Unsplash.Download.Response](#anytype-Rpc-Unsplash-Download-Response) | UnsplashDownload downloads picture from unsplash by ID, put it to the IPFS and returns the hash. The artist info is available in the object details |
| DownloadManifest | [Rpc.DownloadManifest.Request](#anytype-Rpc-DownloadManifest-Request) | [Rpc.DownloadManifest.Response](#anytype-Rpc-DownloadManifest-Response) | |
| GalleryDownloadManifest | [Rpc.Gallery.DownloadManifest.Request](#anytype-Rpc-Gallery-DownloadManifest-Request) | [Rpc.Gallery.DownloadManifest.Response](#anytype-Rpc-Gallery-DownloadManifest-Response) | |
| GalleryDownloadIndex | [Rpc.Gallery.DownloadIndex.Request](#anytype-Rpc-Gallery-DownloadIndex-Request) | [Rpc.Gallery.DownloadIndex.Response](#anytype-Rpc-Gallery-DownloadIndex-Response) | |
| BlockUpload | [Rpc.Block.Upload.Request](#anytype-Rpc-Block-Upload-Request) | [Rpc.Block.Upload.Response](#anytype-Rpc-Block-Upload-Response) | General Block commands *** |
| BlockReplace | [Rpc.Block.Replace.Request](#anytype-Rpc-Block-Replace-Request) | [Rpc.Block.Replace.Response](#anytype-Rpc-Block-Replace-Response) | |
| BlockCreate | [Rpc.Block.Create.Request](#anytype-Rpc-Block-Create-Request) | [Rpc.Block.Create.Response](#anytype-Rpc-Block-Create-Response) | |
@ -4431,6 +4439,7 @@ Makes blocks copy by given ids and paste it to shown place
| htmlSlot | [string](#string) | | |
| anySlot | [model.Block](#anytype-model-Block) | repeated | |
| fileSlot | [Rpc.Block.Paste.Request.File](#anytype-Rpc-Block-Paste-Request-File) | repeated | |
| url | [string](#string) | | |
@ -4508,6 +4517,7 @@ Makes blocks copy by given ids and paste it to shown place
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| html | [string](#string) | | |
| url | [string](#string) | | |
@ -9762,89 +9772,6 @@ Get marks list in the selected range in text block.
<a name="anytype-Rpc-DownloadManifest"></a>
### Rpc.DownloadManifest
<a name="anytype-Rpc-DownloadManifest-Request"></a>
### Rpc.DownloadManifest.Request
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| url | [string](#string) | | |
<a name="anytype-Rpc-DownloadManifest-Response"></a>
### Rpc.DownloadManifest.Response
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| error | [Rpc.DownloadManifest.Response.Error](#anytype-Rpc-DownloadManifest-Response-Error) | | |
| info | [Rpc.DownloadManifest.Response.ManifestInfo](#anytype-Rpc-DownloadManifest-Response-ManifestInfo) | | |
<a name="anytype-Rpc-DownloadManifest-Response-Error"></a>
### Rpc.DownloadManifest.Response.Error
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| code | [Rpc.DownloadManifest.Response.Error.Code](#anytype-Rpc-DownloadManifest-Response-Error-Code) | | |
| description | [string](#string) | | |
<a name="anytype-Rpc-DownloadManifest-Response-ManifestInfo"></a>
### Rpc.DownloadManifest.Response.ManifestInfo
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| schema | [string](#string) | | |
| id | [string](#string) | | |
| name | [string](#string) | | |
| author | [string](#string) | | |
| license | [string](#string) | | |
| title | [string](#string) | | |
| description | [string](#string) | | |
| screenshots | [string](#string) | repeated | |
| downloadLink | [string](#string) | | |
| fileSize | [int32](#int32) | | |
| categories | [string](#string) | repeated | |
| language | [string](#string) | | |
<a name="anytype-Rpc-File"></a>
### Rpc.File
@ -10341,6 +10268,7 @@ Get marks list in the selected range in text block.
| disableEncryption | [bool](#bool) | | deprecated, has no affect, GO-1926 |
| style | [model.Block.Content.File.Style](#anytype-model-Block-Content-File-Style) | | |
| details | [google.protobuf.Struct](#google-protobuf-Struct) | | additional details for file object |
| origin | [model.ObjectOrigin](#anytype-model-ObjectOrigin) | | |
@ -10380,6 +10308,142 @@ Get marks list in the selected range in text block.
<a name="anytype-Rpc-Gallery"></a>
### Rpc.Gallery
<a name="anytype-Rpc-Gallery-DownloadIndex"></a>
### Rpc.Gallery.DownloadIndex
<a name="anytype-Rpc-Gallery-DownloadIndex-Request"></a>
### Rpc.Gallery.DownloadIndex.Request
<a name="anytype-Rpc-Gallery-DownloadIndex-Response"></a>
### Rpc.Gallery.DownloadIndex.Response
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| error | [Rpc.Gallery.DownloadIndex.Response.Error](#anytype-Rpc-Gallery-DownloadIndex-Response-Error) | | |
| categories | [Rpc.Gallery.DownloadIndex.Response.Category](#anytype-Rpc-Gallery-DownloadIndex-Response-Category) | repeated | |
| experiences | [model.ManifestInfo](#anytype-model-ManifestInfo) | repeated | |
<a name="anytype-Rpc-Gallery-DownloadIndex-Response-Category"></a>
### Rpc.Gallery.DownloadIndex.Response.Category
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| name | [string](#string) | | |
| experiences | [string](#string) | repeated | |
<a name="anytype-Rpc-Gallery-DownloadIndex-Response-Error"></a>
### Rpc.Gallery.DownloadIndex.Response.Error
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| code | [Rpc.Gallery.DownloadIndex.Response.Error.Code](#anytype-Rpc-Gallery-DownloadIndex-Response-Error-Code) | | |
| description | [string](#string) | | |
<a name="anytype-Rpc-Gallery-DownloadManifest"></a>
### Rpc.Gallery.DownloadManifest
<a name="anytype-Rpc-Gallery-DownloadManifest-Request"></a>
### Rpc.Gallery.DownloadManifest.Request
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| url | [string](#string) | | |
<a name="anytype-Rpc-Gallery-DownloadManifest-Response"></a>
### Rpc.Gallery.DownloadManifest.Response
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| error | [Rpc.Gallery.DownloadManifest.Response.Error](#anytype-Rpc-Gallery-DownloadManifest-Response-Error) | | |
| info | [model.ManifestInfo](#anytype-model-ManifestInfo) | | |
<a name="anytype-Rpc-Gallery-DownloadManifest-Response-Error"></a>
### Rpc.Gallery.DownloadManifest.Response.Error
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| code | [Rpc.Gallery.DownloadManifest.Response.Error.Code](#anytype-Rpc-Gallery-DownloadManifest-Response-Error-Code) | | |
| description | [string](#string) | | |
<a name="anytype-Rpc-GenericErrorResponse"></a>
### Rpc.GenericErrorResponse
@ -18429,19 +18493,6 @@ Middleware-to-front-end response, that can contain a NULL error or a non-NULL er
<a name="anytype-Rpc-DownloadManifest-Response-Error-Code"></a>
### Rpc.DownloadManifest.Response.Error.Code
| Name | Number | Description |
| ---- | ------ | ----------- |
| NULL | 0 | |
| UNKNOWN_ERROR | 1 | |
| BAD_INPUT | 2 | |
<a name="anytype-Rpc-File-Download-Response-Error-Code"></a>
### Rpc.File.Download.Response.Error.Code
@ -18549,6 +18600,34 @@ Middleware-to-front-end response, that can contain a NULL error or a non-NULL er
<a name="anytype-Rpc-Gallery-DownloadIndex-Response-Error-Code"></a>
### Rpc.Gallery.DownloadIndex.Response.Error.Code
| Name | Number | Description |
| ---- | ------ | ----------- |
| NULL | 0 | |
| UNKNOWN_ERROR | 1 | |
| BAD_INPUT | 2 | |
| UNMARSHALLING_ERROR | 3 | |
| DOWNLOAD_ERROR | 4 | |
<a name="anytype-Rpc-Gallery-DownloadManifest-Response-Error-Code"></a>
### Rpc.Gallery.DownloadManifest.Response.Error.Code
| Name | Number | Description |
| ---- | ------ | ----------- |
| NULL | 0 | |
| UNKNOWN_ERROR | 1 | |
| BAD_INPUT | 2 | |
<a name="anytype-Rpc-GenericErrorResponse-Error-Code"></a>
### Rpc.GenericErrorResponse.Error.Code
@ -24178,6 +24257,32 @@ Used to decode block meta only, without the content itself
<a name="anytype-model-ManifestInfo"></a>
### ManifestInfo
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| schema | [string](#string) | | |
| id | [string](#string) | | |
| name | [string](#string) | | |
| author | [string](#string) | | |
| license | [string](#string) | | |
| title | [string](#string) | | |
| description | [string](#string) | | |
| screenshots | [string](#string) | repeated | |
| downloadLink | [string](#string) | | |
| fileSize | [int32](#int32) | | |
| categories | [string](#string) | repeated | |
| language | [string](#string) | | |
<a name="anytype-model-Metadata"></a>
### Metadata
@ -25101,6 +25206,7 @@ stored |
| ---- | ------ | ----------- |
| NotIndexed | 0 | |
| Indexed | 1 | |
| NotFound | 2 | |

8
go.mod
View file

@ -89,7 +89,7 @@ require (
golang.org/x/exp v0.0.0-20231006140011-7918f672742d
golang.org/x/image v0.15.0
golang.org/x/mobile v0.0.0-20231006135142-2b44d11868fe
golang.org/x/net v0.20.0
golang.org/x/net v0.21.0
golang.org/x/oauth2 v0.16.0
golang.org/x/text v0.14.0
google.golang.org/grpc v1.61.0
@ -251,11 +251,11 @@ require (
go.opencensus.io v0.24.0 // indirect
go.opentelemetry.io/otel v1.14.0 // indirect
go.opentelemetry.io/otel/trace v1.14.0 // indirect
golang.org/x/crypto v0.18.0 // indirect
golang.org/x/crypto v0.19.0 // indirect
golang.org/x/mod v0.13.0 // indirect
golang.org/x/sync v0.5.0 // indirect
golang.org/x/sys v0.16.0 // indirect
golang.org/x/term v0.16.0 // indirect
golang.org/x/sys v0.17.0 // indirect
golang.org/x/term v0.17.0 // indirect
golang.org/x/tools v0.14.0 // indirect
google.golang.org/appengine v1.6.8 // indirect
google.golang.org/genproto v0.0.0-20231106174013-bbf56f31fb17 // indirect

15
go.sum
View file

@ -1576,8 +1576,8 @@ golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@ -1694,8 +1694,8 @@ golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@ -1819,8 +1819,9 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@ -1828,8 +1829,8 @@ golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
golang.org/x/term v0.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE=
golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
golang.org/x/term v0.17.0 h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U=
golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

3443
pb/commands.pb.go
View file

File diff suppressed because it is too large Load diff

81
pb/protos/commands.proto
View file

@ -3020,6 +3020,7 @@ message Rpc {
bool disableEncryption = 4; // deprecated, has no affect, GO-1926
anytype.model.Block.Content.File.Style style = 5;
google.protobuf.Struct details = 7; // additional details for file object
anytype.model.ObjectOrigin origin = 8;
}
message Response {
@ -3376,39 +3377,55 @@ message Rpc {
}
}
message DownloadManifest {
message Request {
string url = 1;
}
message Response {
Error error = 1;
ManifestInfo info = 2;
message Error {
Code code = 1;
string description = 2;
enum Code {
NULL = 0;
UNKNOWN_ERROR = 1;
BAD_INPUT = 2;
}
message Gallery {
message DownloadManifest {
message Request {
string url = 1;
}
message ManifestInfo {
string schema = 1;
string id = 2;
string name = 3;
string author = 4;
string license = 5;
string title = 6;
string description = 7;
repeated string screenshots = 8;
string downloadLink = 9;
int32 fileSize = 10;
repeated string categories = 11;
string language = 12;
message Response {
Error error = 1;
anytype.model.ManifestInfo info = 2;
message Error {
Code code = 1;
string description = 2;
enum Code {
NULL = 0;
UNKNOWN_ERROR = 1;
BAD_INPUT = 2;
}
}
}
}
message DownloadIndex {
message Request {
}
message Response {
Error error = 1;
repeated Category categories = 2;
repeated anytype.model.ManifestInfo experiences = 3;
message Error {
Code code = 1;
string description = 2;
enum Code {
NULL = 0;
UNKNOWN_ERROR = 1;
BAD_INPUT = 2;
UNMARSHALLING_ERROR = 3;
DOWNLOAD_ERROR = 4;
}
}
message Category {
string name = 1;
repeated string experiences = 2;
}
}
}
}
@ -3544,6 +3561,7 @@ message Rpc {
string htmlSlot = 7;
repeated anytype.model.Block anySlot = 8;
repeated File fileSlot = 9;
string url = 10;
message File {
string name = 1;
@ -4088,6 +4106,7 @@ message Rpc {
message Preview {
message Request {
string html = 1;
string url = 2;
}
message Response {

3
pb/protos/service/service.proto
View file

@ -167,7 +167,8 @@ service ClientCommands {
// The artist info is available in the object details
rpc UnsplashDownload (anytype.Rpc.Unsplash.Download.Request) returns (anytype.Rpc.Unsplash.Download.Response);
rpc DownloadManifest (anytype.Rpc.DownloadManifest.Request) returns (anytype.Rpc.DownloadManifest.Response);
rpc GalleryDownloadManifest (anytype.Rpc.Gallery.DownloadManifest.Request) returns (anytype.Rpc.Gallery.DownloadManifest.Response);
rpc GalleryDownloadIndex (anytype.Rpc.Gallery.DownloadIndex.Request) returns (anytype.Rpc.Gallery.DownloadIndex.Response);
// General Block commands
// ***

605
pb/service/service.pb.go
View file

@ -26,277 +26,278 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
func init() { proto.RegisterFile("pb/protos/service/service.proto", fileDescriptor_93a29dc403579097) }
var fileDescriptor_93a29dc403579097 = []byte{
// 4306 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x9c, 0xcd, 0x6f, 0x24, 0x49,
0x56, 0xc0, 0xa7, 0x2e, 0x0c, 0xe4, 0xb2, 0xc3, 0x52, 0x0b, 0xc3, 0x6c, 0xb3, 0xeb, 0x9e, 0xe9,
0xe9, 0xb6, 0xbb, 0xdb, 0xed, 0x72, 0x4f, 0xf7, 0x4c, 0xcf, 0xb2, 0x8b, 0x84, 0xdc, 0x76, 0xdb,
0x63, 0xd6, 0x76, 0x1b, 0x97, 0xdd, 0x2d, 0x8d, 0x84, 0x44, 0x3a, 0x2b, 0x5c, 0x4e, 0x9c, 0x95,
0x91, 0x9b, 0x19, 0x55, 0xb6, 0x41, 0x20, 0x10, 0x08, 0x04, 0x02, 0x81, 0xf8, 0xba, 0x70, 0x40,
0xe2, 0x0f, 0xe1, 0x86, 0xc4, 0x71, 0x8e, 0x1c, 0xd1, 0xcc, 0x3f, 0x82, 0x32, 0xe2, 0x65, 0x7c,
0xbc, 0x8c, 0x17, 0x99, 0x35, 0x27, 0x5b, 0xf5, 0x7e, 0xef, 0x23, 0x32, 0x5e, 0x7c, 0x47, 0x66,
0x74, 0xb7, 0x38, 0xdf, 0x2c, 0x4a, 0x2e, 0x78, 0xb5, 0x59, 0xb1, 0x72, 0x91, 0x26, 0xac, 0xf9,
0x3b, 0x92, 0x3f, 0x0f, 0xdf, 0x8d, 0xf3, 0x5b, 0x71, 0x5b, 0xb0, 0x3b, 0x1f, 0x18, 0x32, 0xe1,
0xb3, 0x59, 0x9c, 0x4f, 0x2a, 0x85, 0xdc, 0x79, 0xdf, 0x48, 0xd8, 0x82, 0xe5, 0x02, 0x7e, 0x7f,
0xf6, 0xdf, 0xff, 0x35, 0x88, 0xde, 0xdb, 0xce, 0x52, 0x96, 0x8b, 0x6d, 0xd0, 0x18, 0x7e, 0x19,
0x7d, 0x77, 0xab, 0x28, 0xf6, 0x98, 0x78, 0xc3, 0xca, 0x2a, 0xe5, 0xf9, 0xf0, 0xe3, 0x11, 0x38,
0x18, 0x9d, 0x14, 0xc9, 0x68, 0xab, 0x28, 0x46, 0x46, 0x38, 0x3a, 0x61, 0x3f, 0x9f, 0xb3, 0x4a,
0xdc, 0xb9, 0x1f, 0x86, 0xaa, 0x82, 0xe7, 0x15, 0x1b, 0x5e, 0x44, 0xbf, 0xba, 0x55, 0x14, 0x63,
0x26, 0x76, 0x58, 0x5d, 0x80, 0xb1, 0x88, 0x05, 0x1b, 0xae, 0xb5, 0x54, 0x5d, 0x40, 0xfb, 0x78,
0xd8, 0x0d, 0x82, 0x9f, 0xd3, 0xe8, 0x3b, 0xb5, 0x9f, 0xcb, 0xb9, 0x98, 0xf0, 0xeb, 0x7c, 0xf8,
0x51, 0x5b, 0x11, 0x44, 0xda, 0xf6, 0xbd, 0x10, 0x02, 0x56, 0xdf, 0x46, 0xbf, 0xfc, 0x36, 0xce,
0x32, 0x26, 0xb6, 0x4b, 0x56, 0x07, 0xee, 0xea, 0x28, 0xd1, 0x48, 0xc9, 0xb4, 0xdd, 0x8f, 0x83,
0x0c, 0x18, 0xfe, 0x32, 0xfa, 0xae, 0x92, 0x9c, 0xb0, 0x84, 0x2f, 0x58, 0x39, 0xf4, 0x6a, 0x81,
0x90, 0x78, 0xe4, 0x2d, 0x08, 0xdb, 0xde, 0xe6, 0xf9, 0x82, 0x95, 0xc2, 0x6f, 0x1b, 0x84, 0x61,
0xdb, 0x06, 0x02, 0xdb, 0x7f, 0x33, 0x88, 0x7e, 0xb8, 0x95, 0x24, 0x7c, 0x9e, 0x8b, 0x03, 0x9e,
0xc4, 0xd9, 0x41, 0x9a, 0x5f, 0x1d, 0xb1, 0xeb, 0xed, 0xcb, 0x9a, 0xcf, 0xa7, 0x6c, 0xf8, 0xdc,
0x7d, 0xaa, 0x0a, 0x1d, 0x69, 0x76, 0x64, 0xc3, 0xda, 0xf7, 0xa7, 0xcb, 0x29, 0x41, 0x2c, 0xff,
0x30, 0x88, 0x56, 0x70, 0x2c, 0x63, 0x9e, 0x2d, 0x98, 0x89, 0xe6, 0xb3, 0x0e, 0xc3, 0x2e, 0xae,
0xe3, 0x79, 0xb1, 0xac, 0x1a, 0x44, 0x94, 0x45, 0xdf, 0xb7, 0xd3, 0x65, 0xcc, 0x2a, 0xd9, 0x9c,
0x1e, 0xd1, 0x19, 0x01, 0x88, 0xf6, 0xfc, 0xb8, 0x0f, 0x0a, 0xde, 0xd2, 0x68, 0x08, 0xde, 0x32,
0x5e, 0x69, 0x67, 0x0f, 0xbd, 0x16, 0x2c, 0x42, 0xfb, 0x7a, 0xd4, 0x83, 0x04, 0x57, 0x7f, 0x10,
0xfd, 0xca, 0x5b, 0x5e, 0x5e, 0x55, 0x45, 0x9c, 0x30, 0x68, 0x0a, 0x0f, 0x5c, 0xed, 0x46, 0x8a,
0x5b, 0xc3, 0x6a, 0x17, 0x66, 0x25, 0x6d, 0x23, 0x7c, 0x5d, 0x30, 0xdc, 0x07, 0x19, 0xc5, 0x5a,
0x48, 0x25, 0x2d, 0x86, 0xc0, 0xf6, 0x55, 0x34, 0x34, 0xb6, 0xcf, 0xff, 0x90, 0x25, 0x62, 0x6b,
0x32, 0xc1, 0xb5, 0x62, 0x74, 0x25, 0x31, 0xda, 0x9a, 0x4c, 0xa8, 0x5a, 0xf1, 0xa3, 0xe0, 0xec,
0x3a, 0x7a, 0x1f, 0x39, 0x3b, 0x48, 0x2b, 0xe9, 0x70, 0x23, 0x6c, 0x05, 0x30, 0xed, 0x74, 0xd4,
0x17, 0x07, 0xc7, 0x7f, 0x36, 0x88, 0x7e, 0xe0, 0xf1, 0x7c, 0xc2, 0x66, 0x7c, 0xc1, 0x86, 0x4f,
0xbb, 0xad, 0x29, 0x52, 0xfb, 0xff, 0x64, 0x09, 0x0d, 0x4f, 0x9a, 0x8c, 0x59, 0xc6, 0x12, 0x41,
0xa6, 0x89, 0x12, 0x77, 0xa6, 0x89, 0xc6, 0xac, 0x16, 0xd6, 0x08, 0xf7, 0x98, 0xd8, 0x9e, 0x97,
0x25, 0xcb, 0x05, 0x59, 0x97, 0x06, 0xe9, 0xac, 0x4b, 0x07, 0xf5, 0x94, 0x67, 0x8f, 0x89, 0xad,
0x2c, 0x23, 0xcb, 0xa3, 0xc4, 0x9d, 0xe5, 0xd1, 0x18, 0x78, 0x48, 0xa2, 0xef, 0x59, 0x4f, 0x4c,
0xec, 0xe7, 0x17, 0x7c, 0x48, 0x3f, 0x0b, 0x29, 0xd7, 0x3e, 0xd6, 0x3a, 0x39, 0x4f, 0x31, 0x5e,
0xdd, 0x14, 0xbc, 0xa4, 0xab, 0x45, 0x89, 0x3b, 0x8b, 0xa1, 0x31, 0xf0, 0xf0, 0xfb, 0xd1, 0x7b,
0xd0, 0x4b, 0x36, 0xe3, 0xd9, 0x7d, 0x6f, 0x17, 0x8a, 0x07, 0xb4, 0x07, 0x1d, 0x94, 0xe9, 0x1c,
0x40, 0x06, 0x9d, 0xcf, 0xc7, 0x5e, 0x3d, 0xd4, 0xf5, 0xdc, 0x0f, 0x43, 0x2d, 0xdb, 0x3b, 0x2c,
0x63, 0xa4, 0x6d, 0x25, 0xec, 0xb0, 0xad, 0x21, 0xb0, 0x5d, 0x46, 0xbf, 0xae, 0x1f, 0x4b, 0x3d,
0x8e, 0x4a, 0x79, 0xdd, 0x49, 0xaf, 0x13, 0xe5, 0xb6, 0x21, 0xed, 0xeb, 0x49, 0x3f, 0xb8, 0x55,
0x1e, 0x68, 0x81, 0xfe, 0xf2, 0xa0, 0xf6, 0x77, 0x3f, 0x0c, 0x81, 0xed, 0xbf, 0x1d, 0x44, 0x3f,
0x02, 0xd9, 0xab, 0x3c, 0x3e, 0xcf, 0x98, 0x1c, 0x12, 0x8f, 0x98, 0xb8, 0xe6, 0xe5, 0xd5, 0xf8,
0x36, 0x4f, 0x88, 0xe1, 0xdf, 0x0f, 0x77, 0x0c, 0xff, 0xa4, 0x92, 0x35, 0xe3, 0x83, 0x82, 0x0a,
0x5e, 0xe0, 0x19, 0x5f, 0x53, 0x02, 0xc1, 0x0b, 0x6a, 0xc6, 0xe7, 0x22, 0x2d, 0xab, 0x87, 0x75,
0xb7, 0xe9, 0xb7, 0x7a, 0x68, 0xf7, 0x93, 0xf7, 0x42, 0x88, 0xe9, 0xb6, 0x9a, 0x04, 0xe6, 0xf9,
0x45, 0x3a, 0x3d, 0x2b, 0x26, 0x75, 0x1a, 0x3f, 0xf2, 0x67, 0xa8, 0x85, 0x10, 0xdd, 0x16, 0x81,
0x82, 0xb7, 0xbf, 0x37, 0x13, 0x23, 0x68, 0x4a, 0xbb, 0x25, 0x9f, 0x1d, 0xb0, 0x69, 0x9c, 0xdc,
0x42, 0xfb, 0xff, 0x34, 0xd4, 0xf0, 0x30, 0xad, 0x83, 0xf8, 0x6c, 0x49, 0x2d, 0x88, 0xe7, 0x3f,
0x06, 0xd1, 0xfd, 0xa6, 0xf8, 0x97, 0x71, 0x3e, 0x65, 0x50, 0x9f, 0x2a, 0xfa, 0xad, 0x7c, 0x72,
0xc2, 0x2a, 0x11, 0x97, 0x62, 0xf8, 0x13, 0x7f, 0x21, 0x43, 0x3a, 0x3a, 0xb6, 0x9f, 0x7e, 0x2b,
0x5d, 0x53, 0xeb, 0xe3, 0xba, 0x63, 0x83, 0x2e, 0xc0, 0xad, 0x75, 0x29, 0xc1, 0x1d, 0xc0, 0xbd,
0x10, 0x62, 0x6a, 0x5d, 0x0a, 0xf6, 0xf3, 0x45, 0x2a, 0xd8, 0x1e, 0xcb, 0x59, 0xd9, 0xae, 0x75,
0xa5, 0xea, 0x22, 0x44, 0xad, 0x13, 0xa8, 0xe9, 0x6c, 0x1c, 0x6f, 0x7a, 0x70, 0x5c, 0x0f, 0x18,
0x69, 0x0d, 0x8f, 0x4f, 0xfa, 0xc1, 0x66, 0x75, 0x67, 0xf9, 0x3c, 0x61, 0x0b, 0x7e, 0x85, 0x57,
0x77, 0xb6, 0x09, 0x05, 0x10, 0xab, 0x3b, 0x2f, 0x68, 0x46, 0x30, 0xcb, 0xcf, 0x9b, 0x94, 0x5d,
0xa3, 0x11, 0xcc, 0x56, 0xae, 0xc5, 0xc4, 0x08, 0xe6, 0xc1, 0xc0, 0xc3, 0x51, 0xf4, 0x4b, 0x52,
0xf8, 0xbb, 0x3c, 0xcd, 0x87, 0x77, 0x3d, 0x4a, 0xb5, 0x40, 0x5b, 0xfd, 0x90, 0x06, 0x50, 0xc4,
0xf5, 0xaf, 0xdb, 0x71, 0x9e, 0xb0, 0xcc, 0x1b, 0xb1, 0x11, 0x07, 0x23, 0x76, 0x30, 0x14, 0xf1,
0xab, 0x9b, 0x54, 0x78, 0x23, 0xae, 0x05, 0xc1, 0x88, 0x01, 0x40, 0xd9, 0x0a, 0x1a, 0x5b, 0x45,
0x51, 0xd6, 0x3d, 0xa0, 0x2f, 0x5b, 0x5d, 0x24, 0x98, 0xad, 0x2d, 0xd4, 0xef, 0x6d, 0x87, 0x25,
0x59, 0x9a, 0x07, 0xbd, 0x01, 0xd2, 0xc7, 0x9b, 0x41, 0xc1, 0xdb, 0x3c, 0x7a, 0x5f, 0x02, 0xc7,
0x71, 0x29, 0xd2, 0x24, 0x2d, 0xe2, 0xbc, 0x99, 0x17, 0xfb, 0xf2, 0xbd, 0x45, 0x69, 0x9f, 0x1b,
0x3d, 0x69, 0x70, 0xfb, 0x6f, 0x83, 0xe8, 0x23, 0xec, 0xf7, 0x98, 0x95, 0xb3, 0x54, 0x2e, 0xaf,
0x2a, 0xd5, 0x39, 0x0d, 0x3f, 0x0f, 0x1b, 0x6d, 0x29, 0xe8, 0x68, 0x7e, 0xbc, 0xbc, 0x22, 0x04,
0xf6, 0x7b, 0x51, 0xa4, 0xa6, 0xf1, 0x72, 0xa9, 0xe5, 0xe6, 0x06, 0xcc, 0xef, 0x9d, 0x75, 0xd6,
0x47, 0x01, 0xc2, 0x74, 0xa1, 0xea, 0x77, 0xb9, 0x82, 0x1c, 0x7a, 0x35, 0xa4, 0x88, 0xe8, 0x42,
0x11, 0x82, 0x03, 0x1d, 0x5f, 0xf2, 0x6b, 0x7f, 0xa0, 0xb5, 0x24, 0x1c, 0x28, 0x10, 0x66, 0x4f,
0x07, 0x02, 0xf5, 0xed, 0xe9, 0x34, 0x61, 0x84, 0xf6, 0x74, 0x30, 0x03, 0x86, 0x79, 0xf4, 0x6b,
0xb6, 0xe1, 0x97, 0x9c, 0x5f, 0xcd, 0xe2, 0xf2, 0x6a, 0xf8, 0x98, 0x56, 0x6e, 0x18, 0xed, 0x68,
0xbd, 0x17, 0x6b, 0xda, 0x90, 0xed, 0xb0, 0x1e, 0x80, 0xcf, 0xca, 0x0c, 0xb5, 0x21, 0xc7, 0x06,
0x20, 0x44, 0x1b, 0x22, 0x50, 0xd3, 0xa3, 0xd9, 0xde, 0xc6, 0x0c, 0xaf, 0x22, 0x1c, 0xf5, 0x31,
0xa3, 0x56, 0x11, 0x1e, 0x0c, 0xa7, 0xd0, 0x5e, 0x19, 0x17, 0x97, 0xfe, 0x14, 0x92, 0xa2, 0x70,
0x0a, 0x35, 0x08, 0xae, 0xef, 0x31, 0x8b, 0xcb, 0xe4, 0xd2, 0x5f, 0xdf, 0x4a, 0x16, 0xae, 0x6f,
0xcd, 0x98, 0x01, 0xd7, 0x36, 0x3c, 0x9e, 0x9f, 0x57, 0x49, 0x99, 0x9e, 0xb3, 0xe1, 0x3a, 0xad,
0xad, 0x21, 0x62, 0xc0, 0x25, 0x61, 0xb3, 0xe7, 0x03, 0x3e, 0x1b, 0xd9, 0xfe, 0xa4, 0x42, 0x7b,
0x3e, 0x8d, 0x0d, 0x8b, 0x20, 0xf6, 0x7c, 0xfc, 0x24, 0x2e, 0xde, 0x5e, 0xc9, 0xe7, 0x45, 0xd5,
0x51, 0x3c, 0x04, 0x85, 0x8b, 0xd7, 0x86, 0xc1, 0xe7, 0x4d, 0xf4, 0x1b, 0xf6, 0x23, 0x3d, 0xcb,
0x2b, 0xed, 0x75, 0x83, 0x7e, 0x4e, 0x16, 0x46, 0xec, 0x9e, 0x04, 0x70, 0xb3, 0x10, 0x6f, 0x3c,
0x8b, 0x1d, 0x26, 0xe2, 0x34, 0xab, 0x86, 0xab, 0x7e, 0x1b, 0x8d, 0x9c, 0x58, 0x88, 0xfb, 0x38,
0xdc, 0x84, 0x76, 0xe6, 0x45, 0x96, 0x26, 0xed, 0x6d, 0x34, 0xd0, 0xd5, 0xe2, 0x70, 0x13, 0xb2,
0x31, 0xdc, 0x25, 0x8c, 0x99, 0x50, 0xff, 0x9c, 0xde, 0x16, 0xcc, 0xdf, 0x25, 0x38, 0x48, 0xb8,
0x4b, 0xc0, 0x28, 0x2e, 0xcf, 0x98, 0x89, 0x83, 0xf8, 0x96, 0xcf, 0x89, 0x2e, 0x41, 0x8b, 0xc3,
0xe5, 0xb1, 0x31, 0x33, 0x70, 0x6b, 0x0f, 0xfb, 0xb9, 0x60, 0x65, 0x1e, 0x67, 0xbb, 0x59, 0x3c,
0xad, 0x86, 0x44, 0xbb, 0x71, 0x29, 0x62, 0xe0, 0xa6, 0x69, 0xcf, 0x63, 0xdc, 0xaf, 0x76, 0xe3,
0x05, 0x2f, 0x53, 0x41, 0x3f, 0x46, 0x83, 0x74, 0x3e, 0x46, 0x07, 0xf5, 0x7a, 0xdb, 0x2a, 0x93,
0xcb, 0x74, 0xc1, 0x26, 0x01, 0x6f, 0x0d, 0xd2, 0xc3, 0x9b, 0x85, 0x7a, 0x2a, 0x6d, 0xcc, 0xe7,
0x65, 0xc2, 0xc8, 0x4a, 0x53, 0xe2, 0xce, 0x4a, 0xd3, 0x18, 0x78, 0xf8, 0xcb, 0x41, 0xf4, 0x9b,
0x4a, 0x6a, 0xef, 0x6d, 0xed, 0xc4, 0xd5, 0xe5, 0x39, 0x8f, 0xcb, 0xc9, 0xf0, 0x13, 0x9f, 0x1d,
0x2f, 0xaa, 0x5d, 0x3f, 0x5b, 0x46, 0x05, 0x3f, 0xd6, 0x83, 0xb4, 0xb2, 0x5a, 0x9c, 0xf7, 0xb1,
0x3a, 0x48, 0xf8, 0xb1, 0x62, 0x14, 0x77, 0x20, 0x52, 0xae, 0xd6, 0x91, 0xab, 0xa4, 0xbe, 0xbb,
0x98, 0x5c, 0xeb, 0xe4, 0x70, 0xff, 0x58, 0x0b, 0xdd, 0x6c, 0xd9, 0xa0, 0x6c, 0xf8, 0x33, 0x66,
0xd4, 0x17, 0x27, 0x3d, 0xeb, 0x56, 0x11, 0xf6, 0xdc, 0x6a, 0x19, 0xa3, 0xbe, 0x38, 0xe1, 0xd9,
0xea, 0xd6, 0x42, 0x9e, 0x3d, 0x5d, 0xdb, 0xa8, 0x2f, 0x8e, 0x13, 0x68, 0xab, 0x28, 0xb2, 0xdb,
0x53, 0x36, 0x2b, 0x32, 0x32, 0x81, 0x1c, 0x24, 0x9c, 0x40, 0x18, 0xc5, 0xb3, 0x9f, 0x53, 0x5e,
0xcf, 0xad, 0xbc, 0xb3, 0x1f, 0x29, 0x0a, 0xcf, 0x7e, 0x1a, 0x04, 0x4f, 0x18, 0x4e, 0xf9, 0x36,
0xcf, 0x32, 0x96, 0x88, 0xf6, 0x21, 0x91, 0xd6, 0x34, 0x44, 0x78, 0xc2, 0x80, 0x48, 0xb3, 0x19,
0xd0, 0xcc, 0xd5, 0xe3, 0x92, 0xbd, 0xbc, 0x3d, 0x48, 0xf3, 0xab, 0xa1, 0x7f, 0x6c, 0x34, 0x00,
0xb1, 0x19, 0xe0, 0x05, 0xf1, 0x9a, 0xe0, 0x2c, 0x9f, 0x70, 0xff, 0x9a, 0xa0, 0x96, 0x84, 0xd7,
0x04, 0x40, 0x60, 0x93, 0x27, 0x8c, 0x32, 0x59, 0x4b, 0xc2, 0x26, 0x81, 0xf0, 0xf5, 0x07, 0xb0,
0xeb, 0x46, 0xf6, 0x07, 0x68, 0x9f, 0x6d, 0xad, 0x93, 0xc3, 0x19, 0xda, 0x2c, 0x0e, 0x76, 0x99,
0x48, 0x2e, 0xfd, 0x19, 0xea, 0x20, 0xe1, 0x0c, 0xc5, 0x28, 0x2e, 0xd2, 0x29, 0xd7, 0x8b, 0x9b,
0x55, 0x7f, 0x7e, 0xb4, 0x16, 0x36, 0x6b, 0x9d, 0x1c, 0x9e, 0xae, 0xef, 0xcf, 0xe4, 0x33, 0xf3,
0x26, 0xb9, 0x92, 0x85, 0xa7, 0xeb, 0x9a, 0xc1, 0xd1, 0x2b, 0x41, 0xfd, 0x38, 0xfd, 0xd1, 0x1b,
0x79, 0x38, 0x7a, 0x87, 0x03, 0x27, 0xff, 0x32, 0x88, 0xee, 0xda, 0x5e, 0x8e, 0x78, 0xdd, 0x46,
0xde, 0xc4, 0x59, 0x3a, 0x89, 0x05, 0x3b, 0xe5, 0x57, 0x2c, 0x47, 0xeb, 0x7d, 0x37, 0x5a, 0xc5,
0x8f, 0x1c, 0x05, 0x62, 0xbd, 0xdf, 0x4b, 0x11, 0xe7, 0x89, 0xa2, 0xcf, 0x2a, 0xb6, 0x1d, 0x57,
0x44, 0x4f, 0xe6, 0x20, 0xe1, 0x3c, 0xc1, 0x28, 0x9e, 0xb4, 0x29, 0xf9, 0xab, 0x9b, 0x82, 0x95,
0x29, 0xcb, 0x13, 0xe6, 0x9f, 0xb4, 0x61, 0x2a, 0x3c, 0x69, 0xf3, 0xd0, 0xad, 0xe5, 0xb0, 0xee,
0x9c, 0xda, 0xe7, 0xbc, 0x98, 0x08, 0x9c, 0xf3, 0x12, 0x28, 0x2e, 0xa4, 0x01, 0xbc, 0x5b, 0x4a,
0x2d, 0x2b, 0xc1, 0x2d, 0x25, 0x9a, 0x6e, 0x6d, 0x32, 0x68, 0x66, 0x5c, 0x37, 0x93, 0x8e, 0xd0,
0xc7, 0x76, 0x73, 0x59, 0xef, 0xc5, 0xfa, 0x77, 0x35, 0x4e, 0x58, 0x16, 0xcb, 0x21, 0x24, 0xb0,
0x75, 0xd0, 0x30, 0x7d, 0x76, 0x35, 0x2c, 0x16, 0x1c, 0xfe, 0xf9, 0x20, 0xba, 0xe3, 0xf3, 0xf8,
0xba, 0x90, 0x7e, 0x9f, 0x76, 0xdb, 0x52, 0x24, 0x71, 0x90, 0x1d, 0xd6, 0x80, 0x18, 0xfe, 0x38,
0xfa, 0xa0, 0x11, 0x99, 0x73, 0x6e, 0x08, 0xc0, 0x9d, 0x45, 0xe8, 0xf8, 0x31, 0xa7, 0xdd, 0x6f,
0xf6, 0xe6, 0xcd, 0x04, 0xdd, 0x8d, 0xab, 0x42, 0x13, 0x74, 0x6d, 0x03, 0xc4, 0xc4, 0x04, 0xdd,
0x83, 0xe1, 0x91, 0xba, 0x41, 0xea, 0x76, 0xe2, 0xeb, 0xe3, 0xb4, 0x09, 0xbb, 0x95, 0x3c, 0xec,
0x06, 0x71, 0xee, 0x34, 0x62, 0x98, 0x17, 0x3f, 0x0e, 0x59, 0x40, 0x73, 0xe3, 0xf5, 0x5e, 0x2c,
0x38, 0xfc, 0xd3, 0xe8, 0x07, 0xad, 0x82, 0xed, 0xb2, 0x58, 0xcc, 0x4b, 0x36, 0x19, 0x6e, 0x76,
0xc4, 0xdd, 0x80, 0xda, 0xf5, 0xd3, 0xfe, 0x0a, 0xe0, 0xff, 0xaf, 0x07, 0xd1, 0x0f, 0x5d, 0x4e,
0x55, 0xb1, 0x8e, 0xe1, 0x59, 0xc8, 0xa4, 0xcb, 0xea, 0x30, 0x9e, 0x2f, 0xa5, 0xd3, 0x5a, 0x83,
0xd9, 0x89, 0xbc, 0xb5, 0x88, 0xd3, 0x2c, 0x3e, 0xcf, 0x98, 0x77, 0x0d, 0xe6, 0xe4, 0xa6, 0x46,
0x83, 0x6b, 0x30, 0x52, 0xa5, 0xd5, 0x4b, 0xca, 0xf6, 0x66, 0xcd, 0xdd, 0x9f, 0xd0, 0xad, 0xd2,
0x33, 0x75, 0xdf, 0xe8, 0x49, 0x83, 0x5b, 0xd1, 0xec, 0x5d, 0xd5, 0x3f, 0xdb, 0x49, 0xee, 0xf3,
0x0a, 0xaa, 0x9e, 0x4c, 0xdf, 0xe8, 0x49, 0x83, 0xd7, 0x3f, 0x89, 0x3e, 0x68, 0x7b, 0x85, 0x41,
0x61, 0xb3, 0xd3, 0x14, 0x1a, 0x17, 0x9e, 0xf6, 0x57, 0x30, 0x53, 0xfd, 0x2f, 0xd2, 0x4a, 0xf0,
0xf2, 0x76, 0x7c, 0xc9, 0xaf, 0x9b, 0xbb, 0x9c, 0x6e, 0x6b, 0x05, 0x60, 0x64, 0x11, 0xc4, 0x54,
0xdf, 0x4f, 0xb6, 0x5c, 0x99, 0x3b, 0x9f, 0x15, 0xe1, 0xca, 0x22, 0x3a, 0x5c, 0xb9, 0xa4, 0xe9,
0xab, 0x9a, 0x52, 0x99, 0x0b, 0xaa, 0x6b, 0xfe, 0x50, 0xdb, 0x97, 0x54, 0x1f, 0x76, 0x83, 0x66,
0xf9, 0xb5, 0x9b, 0x66, 0xec, 0xf5, 0xc5, 0x45, 0xc6, 0xe3, 0x09, 0x5a, 0x7e, 0xd5, 0x92, 0x11,
0x88, 0x88, 0xe5, 0x17, 0x42, 0xcc, 0xa4, 0xb3, 0x16, 0xc8, 0xb3, 0x99, 0xc6, 0xf4, 0x6a, 0x5b,
0xcf, 0x96, 0x13, 0x93, 0x4e, 0x1f, 0x67, 0x06, 0x8c, 0x5a, 0x5a, 0x37, 0xc1, 0xc6, 0xc7, 0x83,
0xb6, 0xae, 0x25, 0x26, 0x06, 0x0c, 0x0f, 0x66, 0xd6, 0x47, 0xb5, 0xf0, 0xac, 0x90, 0xc6, 0x3f,
0x6c, 0x6b, 0x29, 0x09, 0xb1, 0x3e, 0x72, 0x09, 0x33, 0xcf, 0xaf, 0x7f, 0xdf, 0xe1, 0xd7, 0xb9,
0x34, 0xea, 0x79, 0x9a, 0x8d, 0x8c, 0x98, 0xe7, 0x63, 0x06, 0x0c, 0xff, 0x2c, 0xfa, 0x45, 0x69,
0xb8, 0xe4, 0xc5, 0x70, 0xc5, 0xa3, 0x50, 0x5a, 0x37, 0x42, 0xee, 0x92, 0x72, 0x73, 0xb1, 0x49,
0xd7, 0xdf, 0x59, 0x15, 0x4f, 0x19, 0xba, 0xd8, 0x64, 0x6a, 0x45, 0x4a, 0x89, 0x8b, 0x4d, 0x6d,
0xca, 0x5c, 0xd6, 0xa9, 0x65, 0x47, 0x7c, 0x02, 0xd6, 0x3d, 0x25, 0xd4, 0x42, 0xe2, 0xb2, 0x4e,
0x0b, 0x32, 0xfb, 0xf7, 0x47, 0xf1, 0x22, 0x9d, 0xea, 0xce, 0x5f, 0xf5, 0x21, 0x15, 0xda, 0xbf,
0x37, 0xcc, 0xc8, 0x82, 0x88, 0xfd, 0x7b, 0x12, 0x06, 0x9f, 0xff, 0x3c, 0x88, 0x3e, 0x34, 0xcc,
0x5e, 0xb3, 0xad, 0xb2, 0x9f, 0x5f, 0xf0, 0xb7, 0xa9, 0xb8, 0xac, 0xd7, 0xf1, 0xd5, 0xf0, 0x05,
0x65, 0xd2, 0xcf, 0xeb, 0x50, 0x3e, 0x5f, 0x5a, 0xcf, 0xcc, 0xe6, 0x9a, 0xed, 0x16, 0x73, 0xb6,
0xa5, 0x34, 0xd0, 0x6c, 0x4e, 0xef, 0xca, 0x60, 0x8e, 0x98, 0xcd, 0x85, 0x78, 0x53, 0xc5, 0xda,
0x79, 0xc6, 0x73, 0x5c, 0xc5, 0xc6, 0x42, 0x2d, 0x24, 0xaa, 0xb8, 0x05, 0x99, 0xbe, 0xb1, 0x11,
0xa9, 0x9d, 0x81, 0xad, 0x2c, 0x43, 0x7d, 0xa3, 0x56, 0xd5, 0x00, 0xd1, 0x37, 0x7a, 0x41, 0xf0,
0x73, 0x12, 0x7d, 0xa7, 0x7e, 0xa4, 0xc7, 0x25, 0x5b, 0xa4, 0x0c, 0x1f, 0xc3, 0x5a, 0x12, 0xa2,
0xfd, 0xbb, 0x84, 0x69, 0x59, 0x67, 0x79, 0x55, 0x64, 0x71, 0x75, 0x09, 0x07, 0x73, 0x6e, 0x99,
0x1b, 0x21, 0x3e, 0x9a, 0x7b, 0xd0, 0x41, 0x99, 0x8e, 0xb7, 0x91, 0xe9, 0x2e, 0x66, 0xd5, 0xaf,
0xda, 0xea, 0x66, 0xd6, 0x3a, 0x39, 0x70, 0x12, 0x47, 0xdf, 0x6b, 0x7e, 0x3c, 0x8c, 0xf3, 0xf4,
0x82, 0x55, 0xf8, 0x00, 0x04, 0x8b, 0x89, 0x9e, 0xd7, 0x83, 0x99, 0x61, 0xe9, 0x65, 0xc6, 0x93,
0x2b, 0xe8, 0x7a, 0xdd, 0x07, 0x2b, 0x25, 0xb8, 0xef, 0xbd, 0x17, 0x42, 0x4c, 0xe7, 0x2b, 0x05,
0x27, 0xac, 0xc8, 0xe2, 0x04, 0x9f, 0x81, 0x2b, 0x1d, 0x90, 0x11, 0x9d, 0x2f, 0x66, 0x50, 0xb8,
0x70, 0xb6, 0xee, 0x0b, 0x17, 0x1d, 0xad, 0xdf, 0x0b, 0x21, 0x66, 0xf8, 0x91, 0x82, 0x71, 0x91,
0xa5, 0x02, 0xa5, 0x9f, 0xd2, 0x90, 0x12, 0x22, 0xfd, 0x5c, 0x02, 0x99, 0x3c, 0x64, 0xe5, 0x94,
0x79, 0x4d, 0x4a, 0x49, 0xd0, 0x64, 0x43, 0x98, 0x0b, 0x39, 0xaa, 0xec, 0xbc, 0xb8, 0x45, 0x17,
0x72, 0xa0, 0x58, 0xbc, 0xb8, 0x25, 0x2e, 0xe4, 0x38, 0x00, 0x0a, 0xf1, 0x38, 0xae, 0x84, 0x3f,
0x44, 0x29, 0x09, 0x86, 0xd8, 0x10, 0x66, 0x6c, 0x54, 0x21, 0xce, 0x05, 0x1a, 0x1b, 0x21, 0x00,
0xeb, 0x88, 0xee, 0x2e, 0x29, 0x37, 0x2d, 0x58, 0xd5, 0x0a, 0x13, 0xbb, 0x29, 0xcb, 0x26, 0x15,
0x6a, 0xc1, 0xf0, 0xdc, 0x1b, 0x29, 0xd1, 0x82, 0xdb, 0x14, 0x4a, 0x25, 0xd8, 0x3b, 0xf5, 0x95,
0x0e, 0x6d, 0x9b, 0xde, 0x0b, 0x21, 0xa6, 0x5f, 0x68, 0x82, 0xde, 0x8e, 0xcb, 0x32, 0xad, 0x07,
0xdd, 0x55, 0x7f, 0x40, 0x8d, 0x9c, 0xe8, 0x17, 0x7c, 0x1c, 0x6a, 0x5e, 0x4d, 0x87, 0xe9, 0x0b,
0x0c, 0x77, 0x99, 0x1f, 0x07, 0x19, 0x33, 0xd3, 0x93, 0x12, 0xeb, 0x8c, 0xc9, 0xf7, 0x34, 0x3d,
0x47, 0x4c, 0xab, 0x5d, 0x98, 0x75, 0xc5, 0x57, 0xbb, 0x38, 0xe4, 0x0b, 0x76, 0xca, 0x5f, 0xdd,
0xa4, 0x95, 0x48, 0xf3, 0x29, 0x8c, 0x98, 0xcf, 0x09, 0x4b, 0x3e, 0x98, 0xb8, 0xe2, 0xdb, 0xa9,
0x64, 0x06, 0x6e, 0x14, 0xcb, 0x11, 0xbb, 0xf6, 0x0e, 0xdc, 0xd8, 0xa2, 0xe6, 0x88, 0x81, 0x3b,
0xc4, 0x9b, 0xbd, 0x04, 0xed, 0x1c, 0xde, 0x83, 0x3a, 0xe5, 0xcd, 0x1c, 0x8a, 0xb2, 0x86, 0x41,
0x62, 0x39, 0x17, 0x54, 0x30, 0x6b, 0x2c, 0xed, 0xdf, 0x34, 0xb1, 0x87, 0x84, 0x9d, 0x76, 0x33,
0x7b, 0xd4, 0x83, 0xf4, 0xb8, 0x32, 0x07, 0xa5, 0x94, 0xab, 0xf6, 0x39, 0xe9, 0xa3, 0x1e, 0xa4,
0xb5, 0x2f, 0x61, 0x17, 0xeb, 0x65, 0x9c, 0x5c, 0x4d, 0x4b, 0x3e, 0xcf, 0x27, 0xdb, 0x3c, 0xe3,
0x25, 0xda, 0x97, 0x70, 0xa2, 0x46, 0x28, 0xb1, 0x2f, 0xd1, 0xa1, 0x62, 0x66, 0x4e, 0x76, 0x14,
0x5b, 0x59, 0x3a, 0xc5, 0xab, 0x4a, 0xc7, 0x90, 0x04, 0x88, 0x99, 0x93, 0x17, 0xf4, 0x24, 0x91,
0x5a, 0x75, 0x8a, 0x34, 0x89, 0x33, 0xe5, 0x6f, 0x93, 0x36, 0xe3, 0x80, 0x9d, 0x49, 0xe4, 0x51,
0xf0, 0x94, 0xf3, 0x74, 0x5e, 0xe6, 0xfb, 0xb9, 0xe0, 0x64, 0x39, 0x1b, 0xa0, 0xb3, 0x9c, 0x16,
0x88, 0xba, 0xd5, 0x53, 0x76, 0x53, 0x47, 0x53, 0xff, 0xf1, 0x75, 0xab, 0xf5, 0xef, 0x23, 0x90,
0x87, 0xba, 0x55, 0xc4, 0xa1, 0xc2, 0x80, 0x13, 0x95, 0x30, 0x01, 0x6d, 0x37, 0x4d, 0x1e, 0x76,
0x83, 0x7e, 0x3f, 0x63, 0x71, 0x9b, 0xb1, 0x90, 0x1f, 0x09, 0xf4, 0xf1, 0xd3, 0x80, 0xe6, 0xc0,
0xc2, 0x29, 0xcf, 0x25, 0x4b, 0xae, 0x5a, 0xf7, 0x3e, 0xdc, 0x40, 0x15, 0x42, 0x1c, 0x58, 0x10,
0xa8, 0xbf, 0x8a, 0xf6, 0x13, 0x9e, 0x87, 0xaa, 0xa8, 0x96, 0xf7, 0xa9, 0x22, 0xe0, 0xcc, 0xa2,
0x53, 0x4b, 0x21, 0x33, 0x55, 0x35, 0xad, 0x13, 0x16, 0x6c, 0x88, 0x58, 0x74, 0x92, 0xb0, 0xd9,
0x65, 0xc6, 0x3e, 0x0f, 0xdb, 0xf7, 0x2e, 0x5b, 0x56, 0x0e, 0xe9, 0x7b, 0x97, 0x14, 0x4b, 0x17,
0x52, 0xe5, 0x48, 0x87, 0x15, 0x37, 0x4f, 0x9e, 0xf4, 0x83, 0xcd, 0x2d, 0x08, 0xc7, 0xe7, 0x76,
0xc6, 0xe2, 0x52, 0x79, 0xdd, 0x08, 0x18, 0x32, 0x18, 0x71, 0x0b, 0x22, 0x80, 0xa3, 0x2e, 0xcc,
0xf1, 0xbc, 0xcd, 0x73, 0xc1, 0x72, 0xe1, 0xeb, 0xc2, 0x5c, 0x63, 0x00, 0x86, 0xba, 0x30, 0x4a,
0x01, 0xe5, 0xad, 0xdc, 0x87, 0x61, 0xe2, 0x28, 0x9e, 0x79, 0x67, 0x6c, 0x6a, 0x8f, 0x45, 0xc9,
0x43, 0x79, 0x8b, 0x38, 0xd4, 0xe4, 0xf7, 0x67, 0xf1, 0x54, 0x7b, 0xf1, 0x68, 0x4b, 0x79, 0xcb,
0xcd, 0xc3, 0x6e, 0x10, 0xf9, 0x79, 0x93, 0x4e, 0x18, 0x0f, 0xf8, 0x91, 0xf2, 0x3e, 0x7e, 0x30,
0x88, 0x66, 0x4e, 0x75, 0x69, 0xd5, 0x6a, 0x6a, 0x2b, 0x9f, 0xc0, 0x1a, 0x72, 0x44, 0x3c, 0x14,
0xc4, 0x85, 0x66, 0x4e, 0x04, 0x8f, 0xda, 0x47, 0xb3, 0x29, 0x19, 0x6a, 0x1f, 0x7a, 0xcf, 0xb1,
0x4f, 0xfb, 0xf0, 0xc1, 0xe0, 0xf3, 0x8f, 0xa0, 0x7d, 0xec, 0xc4, 0x22, 0xae, 0xe7, 0xcc, 0x6f,
0x52, 0x76, 0x0d, 0x8b, 0x50, 0x4f, 0x79, 0x1b, 0x6a, 0x24, 0x5f, 0x02, 0x41, 0x2b, 0xd2, 0xcd,
0xde, 0x7c, 0xc0, 0x37, 0xcc, 0xce, 0x3b, 0x7d, 0xa3, 0x69, 0xfa, 0x66, 0x6f, 0x3e, 0xe0, 0x1b,
0xde, 0x2e, 0xeb, 0xf4, 0x8d, 0x5e, 0x31, 0xdb, 0xec, 0xcd, 0x83, 0xef, 0xbf, 0x18, 0x44, 0x77,
0x5a, 0xce, 0xeb, 0x39, 0x50, 0x22, 0xd2, 0x05, 0xf3, 0x4d, 0xe5, 0x5c, 0x7b, 0x1a, 0x0d, 0x4d,
0xe5, 0x68, 0x15, 0xeb, 0x93, 0x04, 0xbe, 0x28, 0x8e, 0x79, 0x95, 0xca, 0x03, 0xdb, 0xe7, 0x3d,
0x8c, 0x36, 0x70, 0x68, 0xc1, 0x12, 0x52, 0x32, 0xc7, 0x5d, 0x0e, 0x6a, 0xae, 0x58, 0x3e, 0x09,
0xd8, 0x6b, 0xdf, 0xb4, 0xdc, 0xe8, 0x49, 0x9b, 0x83, 0x27, 0x87, 0xb1, 0x4f, 0xbc, 0x42, 0xb5,
0xea, 0x3d, 0xf4, 0x7a, 0xda, 0x5f, 0x01, 0xdc, 0xff, 0x55, 0x33, 0xa7, 0xc7, 0xfe, 0xa1, 0x11,
0x3c, 0xeb, 0x63, 0x11, 0x35, 0x84, 0xe7, 0x4b, 0xe9, 0x40, 0x20, 0xff, 0x3e, 0x88, 0xee, 0x79,
0x03, 0x71, 0xcf, 0x3e, 0x7f, 0xab, 0x8f, 0x6d, 0xff, 0x19, 0xe8, 0x4f, 0xbe, 0x8d, 0x2a, 0x44,
0xf7, 0x77, 0xcd, 0xd2, 0xba, 0xd1, 0x90, 0xd7, 0xe0, 0x5f, 0x97, 0x13, 0x56, 0x42, 0x8b, 0x0d,
0x25, 0x9d, 0x81, 0x71, 0xbb, 0xfd, 0x6c, 0x49, 0x2d, 0xeb, 0xf3, 0x19, 0x0e, 0x0c, 0x6f, 0x04,
0x59, 0xf1, 0x84, 0x2c, 0x5b, 0x34, 0x0e, 0xe8, 0xc5, 0xb2, 0x6a, 0x54, 0x4b, 0xb6, 0x60, 0xf9,
0x36, 0xee, 0xf3, 0x9e, 0x86, 0x9d, 0xf7, 0x73, 0x3f, 0x5d, 0x4e, 0x09, 0x62, 0xf9, 0xcf, 0x41,
0xf4, 0xc0, 0x61, 0xcd, 0x0e, 0x3f, 0xda, 0x0f, 0xf9, 0x69, 0xc0, 0x3e, 0xa5, 0xa4, 0x83, 0xfb,
0xed, 0x6f, 0xa7, 0x6c, 0xbe, 0x35, 0xe1, 0xa8, 0xec, 0xa6, 0x99, 0x60, 0x65, 0xfb, 0x5b, 0x13,
0xae, 0x5d, 0x45, 0x8d, 0xe8, 0x6f, 0x4d, 0x04, 0x70, 0xeb, 0x5b, 0x13, 0x1e, 0xcf, 0xde, 0x6f,
0x4d, 0x78, 0xad, 0x05, 0xbf, 0x35, 0x11, 0xd6, 0xa0, 0x06, 0x9f, 0x26, 0x04, 0xb5, 0xa3, 0xdd,
0xcb, 0xa2, 0xbb, 0xc1, 0xfd, 0x6c, 0x19, 0x15, 0x62, 0xf8, 0x55, 0x9c, 0xbc, 0x91, 0xd5, 0xe3,
0x99, 0x3a, 0xb7, 0xb2, 0x36, 0x7b, 0xf3, 0xe0, 0xfb, 0xe7, 0xb0, 0xee, 0xd1, 0x83, 0x0d, 0x2f,
0xe5, 0x77, 0x46, 0xd6, 0x43, 0x83, 0x47, 0x6d, 0xc1, 0xae, 0xf9, 0x27, 0xfd, 0x60, 0xa2, 0xb8,
0x35, 0x01, 0x95, 0x3e, 0xea, 0x32, 0x84, 0xaa, 0x7c, 0xb3, 0x37, 0x4f, 0x0c, 0x72, 0xca, 0xb7,
0xaa, 0xed, 0x1e, 0xc6, 0xdc, 0xba, 0x7e, 0xda, 0x5f, 0xc1, 0x5c, 0x29, 0x69, 0xb9, 0x97, 0xf5,
0xdc, 0xf9, 0x04, 0x9d, 0x5a, 0xde, 0xe8, 0x49, 0x87, 0x26, 0x37, 0xf6, 0xf0, 0xde, 0x35, 0xb9,
0xf1, 0x0e, 0xf1, 0x9f, 0x2e, 0xa7, 0x04, 0xb1, 0xfc, 0xd3, 0x20, 0xba, 0x4b, 0xc6, 0x02, 0x59,
0xf0, 0xa2, 0xaf, 0x65, 0x94, 0x0d, 0x9f, 0x2f, 0xad, 0x07, 0x41, 0xfd, 0xeb, 0x20, 0xfa, 0x30,
0x10, 0x94, 0x4a, 0x8f, 0x25, 0xac, 0xbb, 0x69, 0xf2, 0xe3, 0xe5, 0x15, 0xa9, 0xc1, 0xde, 0xc6,
0xc7, 0xed, 0x4f, 0x30, 0x04, 0x6c, 0x8f, 0xe9, 0x4f, 0x30, 0x74, 0x6b, 0xe1, 0xcd, 0x9f, 0x7a,
0x4a, 0x02, 0xeb, 0x22, 0xdf, 0xe6, 0x8f, 0x9c, 0xb1, 0xa0, 0xf5, 0xd0, 0x5a, 0x27, 0xe7, 0x73,
0xf2, 0xea, 0xa6, 0x88, 0xf3, 0x09, 0xed, 0x44, 0xc9, 0xbb, 0x9d, 0x68, 0x0e, 0x6f, 0x9a, 0xd5,
0xd2, 0x13, 0xde, 0x2c, 0xf2, 0x1e, 0x51, 0xfa, 0x1a, 0x09, 0x6e, 0x9a, 0xb5, 0x50, 0xc2, 0x1b,
0xcc, 0x68, 0x43, 0xde, 0xd0, 0x44, 0xf6, 0x71, 0x1f, 0x14, 0x2d, 0x1f, 0xb4, 0x37, 0xbd, 0x17,
0xff, 0x24, 0x64, 0xa5, 0xb5, 0x1f, 0xbf, 0xd1, 0x93, 0x26, 0xdc, 0x8e, 0x99, 0xf8, 0x82, 0xc5,
0x13, 0x56, 0x06, 0xdd, 0x6a, 0xaa, 0x97, 0x5b, 0x9b, 0xf6, 0xb9, 0xdd, 0xe6, 0xd9, 0x7c, 0x96,
0x43, 0x65, 0x92, 0x6e, 0x6d, 0xaa, 0xdb, 0x2d, 0xa2, 0xf1, 0x76, 0xa1, 0x71, 0x2b, 0x27, 0x97,
0x8f, 0xc3, 0x66, 0x9c, 0x39, 0xe5, 0x7a, 0x2f, 0x96, 0x2e, 0x27, 0xa4, 0x51, 0x47, 0x39, 0x51,
0x26, 0x6d, 0xf4, 0xa4, 0xf1, 0xbe, 0x9d, 0xe5, 0x56, 0xe7, 0xd3, 0x66, 0x87, 0xad, 0x56, 0x4a,
0x3d, 0xed, 0xaf, 0x80, 0x77, 0x49, 0x21, 0xab, 0xea, 0x55, 0xd1, 0x6e, 0x9a, 0x65, 0xc3, 0xf5,
0x40, 0x9a, 0x34, 0x50, 0x70, 0x97, 0xd4, 0x03, 0x13, 0x99, 0xdc, 0xec, 0x2a, 0xe6, 0xc3, 0x2e,
0x3b, 0x92, 0xea, 0x95, 0xc9, 0x36, 0x8d, 0x76, 0xdb, 0xac, 0x47, 0xad, 0x4b, 0x3b, 0x0a, 0x3f,
0xb8, 0x56, 0x81, 0x37, 0x7b, 0xf3, 0xe8, 0x18, 0x5e, 0x52, 0x72, 0x64, 0xb9, 0x4f, 0x99, 0x70,
0x46, 0x92, 0x07, 0x1d, 0x14, 0xda, 0xb1, 0x54, 0xcd, 0xe8, 0x6d, 0x3a, 0x99, 0x32, 0xe1, 0x3d,
0x41, 0xb2, 0x81, 0xe0, 0x09, 0x12, 0x02, 0x51, 0xd5, 0xa9, 0xdf, 0xc7, 0x4c, 0x9c, 0xc6, 0xe5,
0x94, 0x89, 0xfd, 0x89, 0xaf, 0xea, 0x40, 0xd9, 0xa2, 0x42, 0x55, 0xe7, 0xa5, 0x51, 0x6f, 0xa0,
0xdd, 0xc2, 0x7b, 0xcc, 0x8f, 0x43, 0x66, 0xd0, 0xcb, 0xcc, 0xeb, 0xbd, 0x58, 0x34, 0xa2, 0x18,
0x87, 0xe9, 0x2c, 0x15, 0xbe, 0x11, 0xc5, 0xb2, 0x51, 0x23, 0xa1, 0x11, 0xa5, 0x8d, 0x52, 0xc5,
0xab, 0xe7, 0x08, 0xfb, 0x93, 0x70, 0xf1, 0x14, 0xd3, 0xaf, 0x78, 0x9a, 0x6d, 0x1d, 0x78, 0xe6,
0x3a, 0x65, 0xc4, 0x25, 0x2c, 0x95, 0x3d, 0xb9, 0x2d, 0x5f, 0xed, 0xc3, 0x60, 0xa8, 0xd7, 0xa1,
0x14, 0xac, 0xb7, 0x47, 0x34, 0xd7, 0x9c, 0xc9, 0x16, 0x05, 0x8b, 0xcb, 0x38, 0x4f, 0xbc, 0x4b,
0x53, 0x69, 0xb0, 0x45, 0x86, 0x96, 0xa6, 0xa4, 0x06, 0x3a, 0x4e, 0x77, 0x5f, 0xca, 0xf3, 0x34,
0x05, 0xfd, 0xf6, 0x9b, 0xfb, 0x4e, 0xde, 0xa3, 0x1e, 0x24, 0x3e, 0x4e, 0x6f, 0x00, 0xbd, 0x29,
0xaf, 0x9c, 0x7e, 0x12, 0x30, 0xe5, 0xa2, 0xa1, 0x65, 0x30, 0xad, 0x82, 0x92, 0x5a, 0x4f, 0x70,
0x99, 0xf8, 0x19, 0xbb, 0xf5, 0x25, 0xb5, 0x99, 0x9f, 0x4a, 0x24, 0x94, 0xd4, 0x6d, 0x14, 0xcd,
0x33, 0xed, 0x75, 0xd0, 0x6a, 0x40, 0xdf, 0x5e, 0xfa, 0xac, 0x75, 0x72, 0xa8, 0xe5, 0xec, 0xa4,
0x0b, 0xe7, 0x0c, 0xc3, 0x13, 0xe8, 0x4e, 0xba, 0xf0, 0x1f, 0x61, 0xac, 0xf7, 0x62, 0xf1, 0x51,
0x7d, 0x2c, 0xd8, 0x4d, 0x73, 0x86, 0xee, 0x09, 0x57, 0xca, 0x5b, 0x87, 0xe8, 0x0f, 0xbb, 0x41,
0x73, 0x21, 0xf5, 0xb8, 0xe4, 0x09, 0xab, 0x2a, 0xf8, 0x2e, 0x95, 0x7b, 0xf3, 0x08, 0x64, 0x23,
0xf4, 0x55, 0xaa, 0xfb, 0x61, 0x08, 0x6c, 0x7f, 0x11, 0xbd, 0x7b, 0xc0, 0xa7, 0x63, 0x96, 0x4f,
0x86, 0x3f, 0x72, 0xaf, 0x80, 0xf2, 0xe9, 0xa8, 0xfe, 0x59, 0xdb, 0x5b, 0xa1, 0xc4, 0xe6, 0x32,
0xdd, 0x0e, 0x3b, 0x9f, 0x4f, 0x4f, 0x4b, 0xc6, 0xd0, 0x65, 0x3a, 0xf9, 0xfb, 0xa8, 0x16, 0x10,
0x97, 0xe9, 0x1c, 0xc0, 0x8c, 0x92, 0xda, 0x5e, 0x3d, 0x11, 0xc5, 0x97, 0xd5, 0x8c, 0x8e, 0x94,
0x12, 0xa3, 0x64, 0x9b, 0x32, 0x95, 0x27, 0x65, 0xf2, 0x92, 0xf7, 0x78, 0x3e, 0x9b, 0xc5, 0xe5,
0x2d, 0xaa, 0x3c, 0xa5, 0x6b, 0x03, 0x44, 0xe5, 0x79, 0x41, 0x93, 0x95, 0xca, 0x8f, 0x88, 0x93,
0xab, 0x3d, 0x5e, 0xf2, 0xb9, 0x48, 0x73, 0x56, 0xa1, 0xac, 0x04, 0x0b, 0x2e, 0x43, 0x64, 0x25,
0xc5, 0x9a, 0x59, 0x9c, 0x24, 0xd4, 0x3d, 0x3a, 0xf9, 0x35, 0xc6, 0x4a, 0xf0, 0x12, 0x9f, 0xe5,
0x29, 0x2b, 0x18, 0x22, 0x66, 0x71, 0x24, 0x8c, 0xea, 0xfe, 0x38, 0xcd, 0xa7, 0xde, 0xba, 0xaf,
0x05, 0xc1, 0xba, 0x07, 0xc0, 0xf4, 0xc7, 0xea, 0xa1, 0xa9, 0xcf, 0xbe, 0xc0, 0x3b, 0x75, 0xde,
0x87, 0x6e, 0x13, 0x44, 0x7f, 0xec, 0x27, 0x91, 0xab, 0xd7, 0x05, 0xcb, 0xd9, 0xa4, 0xb9, 0x2d,
0xe6, 0x73, 0xe5, 0x10, 0x41, 0x57, 0x98, 0x34, 0xa9, 0x70, 0xc8, 0x44, 0x99, 0x26, 0xd5, 0x98,
0x89, 0xe3, 0xb8, 0x8c, 0x67, 0x4c, 0xb0, 0x12, 0xa7, 0x02, 0x20, 0x23, 0x87, 0x21, 0x52, 0x81,
0x62, 0xc1, 0xe1, 0xef, 0x44, 0xdf, 0xaf, 0x7b, 0x2e, 0x96, 0xc3, 0xe7, 0xa1, 0x5f, 0xc9, 0xef,
0xca, 0x0f, 0xdf, 0xd7, 0x36, 0xc6, 0xa2, 0x64, 0xf1, 0xac, 0xb1, 0xfd, 0x9e, 0xfe, 0x5d, 0x82,
0x4f, 0x07, 0x75, 0xbf, 0x7d, 0xc4, 0x45, 0x7a, 0x51, 0x2f, 0x14, 0xe0, 0x50, 0x06, 0xf5, 0xdb,
0xb6, 0x78, 0x14, 0x78, 0x03, 0xdb, 0xc7, 0x99, 0x96, 0x68, 0x4b, 0x4f, 0x58, 0x91, 0xe1, 0x96,
0xe8, 0x68, 0x4b, 0x80, 0x68, 0x89, 0x5e, 0x50, 0xf9, 0x79, 0xf9, 0xd1, 0xff, 0x7c, 0xbd, 0x32,
0xf8, 0xea, 0xeb, 0x95, 0xc1, 0xff, 0x7d, 0xbd, 0x32, 0xf8, 0xc7, 0x6f, 0x56, 0xde, 0xf9, 0xea,
0x9b, 0x95, 0x77, 0xfe, 0xf7, 0x9b, 0x95, 0x77, 0xbe, 0x7c, 0x17, 0x3e, 0xd6, 0x7f, 0xfe, 0x0b,
0xf2, 0x93, 0xfb, 0xcf, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x92, 0xf0, 0xa1, 0xf5, 0xd0, 0x5f,
0x00, 0x00,
// 4333 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x9d, 0xdd, 0x6f, 0x25, 0x47,
0x56, 0xc0, 0x73, 0x5f, 0x08, 0xf4, 0xb2, 0x01, 0xee, 0x42, 0xc8, 0x0e, 0xbb, 0x9e, 0x64, 0x32,
0x63, 0xcf, 0x8c, 0xc7, 0xd7, 0x93, 0x99, 0x64, 0xb2, 0xec, 0x22, 0x21, 0x8f, 0x3d, 0x76, 0xcc,
0xda, 0x1e, 0xe3, 0x6b, 0xcf, 0x48, 0x91, 0x90, 0x68, 0xf7, 0x2d, 0x5f, 0x37, 0xee, 0xdb, 0xd5,
0xdb, 0x5d, 0xf7, 0xda, 0x06, 0x81, 0x40, 0x20, 0x10, 0x08, 0x04, 0xe2, 0xeb, 0x85, 0x07, 0x24,
0xfe, 0x11, 0x5e, 0x79, 0x41, 0xca, 0x23, 0x8f, 0x28, 0xf9, 0x47, 0x56, 0x5d, 0x75, 0xba, 0x3e,
0x4e, 0xd7, 0xa9, 0xee, 0x9b, 0xa7, 0x89, 0x7c, 0x7e, 0xe7, 0xa3, 0xba, 0x4e, 0x55, 0x9d, 0xaa,
0xea, 0xdb, 0x89, 0xee, 0x16, 0xe7, 0x9b, 0x45, 0xc9, 0x05, 0xaf, 0x36, 0x2b, 0x56, 0x2e, 0xd2,
0x84, 0x35, 0xff, 0x8e, 0xe4, 0x9f, 0x87, 0xef, 0xc6, 0xf9, 0xad, 0xb8, 0x2d, 0xd8, 0x9d, 0x0f,
0x0c, 0x99, 0xf0, 0xd9, 0x2c, 0xce, 0x27, 0x95, 0x42, 0xee, 0xbc, 0x6f, 0x24, 0x6c, 0xc1, 0x72,
0x01, 0x7f, 0x7f, 0xf6, 0xbf, 0xff, 0x3d, 0x88, 0xde, 0xdb, 0xce, 0x52, 0x96, 0x8b, 0x6d, 0xd0,
0x18, 0x7e, 0x19, 0x7d, 0x77, 0xab, 0x28, 0xf6, 0x98, 0x78, 0xc3, 0xca, 0x2a, 0xe5, 0xf9, 0xf0,
0xe3, 0x11, 0x38, 0x18, 0x9d, 0x14, 0xc9, 0x68, 0xab, 0x28, 0x46, 0x46, 0x38, 0x3a, 0x61, 0x3f,
0x9b, 0xb3, 0x4a, 0xdc, 0xb9, 0x1f, 0x86, 0xaa, 0x82, 0xe7, 0x15, 0x1b, 0x5e, 0x44, 0xbf, 0xb6,
0x55, 0x14, 0x63, 0x26, 0x76, 0x58, 0xdd, 0x80, 0xb1, 0x88, 0x05, 0x1b, 0xae, 0xb5, 0x54, 0x5d,
0x40, 0xfb, 0x78, 0xd8, 0x0d, 0x82, 0x9f, 0xd3, 0xe8, 0x3b, 0xb5, 0x9f, 0xcb, 0xb9, 0x98, 0xf0,
0xeb, 0x7c, 0xf8, 0x51, 0x5b, 0x11, 0x44, 0xda, 0xf6, 0xbd, 0x10, 0x02, 0x56, 0xdf, 0x46, 0xbf,
0xfc, 0x36, 0xce, 0x32, 0x26, 0xb6, 0x4b, 0x56, 0x07, 0xee, 0xea, 0x28, 0xd1, 0x48, 0xc9, 0xb4,
0xdd, 0x8f, 0x83, 0x0c, 0x18, 0xfe, 0x32, 0xfa, 0xae, 0x92, 0x9c, 0xb0, 0x84, 0x2f, 0x58, 0x39,
0xf4, 0x6a, 0x81, 0x90, 0x78, 0xe4, 0x2d, 0x08, 0xdb, 0xde, 0xe6, 0xf9, 0x82, 0x95, 0xc2, 0x6f,
0x1b, 0x84, 0x61, 0xdb, 0x06, 0x02, 0xdb, 0x7f, 0x3b, 0x88, 0x7e, 0xb0, 0x95, 0x24, 0x7c, 0x9e,
0x8b, 0x03, 0x9e, 0xc4, 0xd9, 0x41, 0x9a, 0x5f, 0x1d, 0xb1, 0xeb, 0xed, 0xcb, 0x9a, 0xcf, 0xa7,
0x6c, 0xf8, 0xdc, 0x7d, 0xaa, 0x0a, 0x1d, 0x69, 0x76, 0x64, 0xc3, 0xda, 0xf7, 0xa7, 0xcb, 0x29,
0x41, 0x2c, 0xff, 0x38, 0x88, 0x56, 0x70, 0x2c, 0x63, 0x9e, 0x2d, 0x98, 0x89, 0xe6, 0xb3, 0x0e,
0xc3, 0x2e, 0xae, 0xe3, 0x79, 0xb1, 0xac, 0x1a, 0x44, 0x94, 0x45, 0xdf, 0xb3, 0xd3, 0x65, 0xcc,
0x2a, 0x39, 0x9c, 0x1e, 0xd1, 0x19, 0x01, 0x88, 0xf6, 0xfc, 0xb8, 0x0f, 0x0a, 0xde, 0xd2, 0x68,
0x08, 0xde, 0x32, 0x5e, 0x69, 0x67, 0x0f, 0xbd, 0x16, 0x2c, 0x42, 0xfb, 0x7a, 0xd4, 0x83, 0x04,
0x57, 0x7f, 0x18, 0xfd, 0xca, 0x5b, 0x5e, 0x5e, 0x55, 0x45, 0x9c, 0x30, 0x18, 0x0a, 0x0f, 0x5c,
0xed, 0x46, 0x8a, 0x47, 0xc3, 0x6a, 0x17, 0x66, 0x25, 0x6d, 0x23, 0x7c, 0x5d, 0x30, 0x3c, 0x07,
0x19, 0xc5, 0x5a, 0x48, 0x25, 0x2d, 0x86, 0xc0, 0xf6, 0x55, 0x34, 0x34, 0xb6, 0xcf, 0xff, 0x88,
0x25, 0x62, 0x6b, 0x32, 0xc1, 0xbd, 0x62, 0x74, 0x25, 0x31, 0xda, 0x9a, 0x4c, 0xa8, 0x5e, 0xf1,
0xa3, 0xe0, 0xec, 0x3a, 0x7a, 0x1f, 0x39, 0x3b, 0x48, 0x2b, 0xe9, 0x70, 0x23, 0x6c, 0x05, 0x30,
0xed, 0x74, 0xd4, 0x17, 0x07, 0xc7, 0x7f, 0x3e, 0x88, 0xbe, 0xef, 0xf1, 0x7c, 0xc2, 0x66, 0x7c,
0xc1, 0x86, 0x4f, 0xbb, 0xad, 0x29, 0x52, 0xfb, 0xff, 0x64, 0x09, 0x0d, 0x4f, 0x9a, 0x8c, 0x59,
0xc6, 0x12, 0x41, 0xa6, 0x89, 0x12, 0x77, 0xa6, 0x89, 0xc6, 0xac, 0x11, 0xd6, 0x08, 0xf7, 0x98,
0xd8, 0x9e, 0x97, 0x25, 0xcb, 0x05, 0xd9, 0x97, 0x06, 0xe9, 0xec, 0x4b, 0x07, 0xf5, 0xb4, 0x67,
0x8f, 0x89, 0xad, 0x2c, 0x23, 0xdb, 0xa3, 0xc4, 0x9d, 0xed, 0xd1, 0x18, 0x78, 0x48, 0xa2, 0x5f,
0xb5, 0x9e, 0x98, 0xd8, 0xcf, 0x2f, 0xf8, 0x90, 0x7e, 0x16, 0x52, 0xae, 0x7d, 0xac, 0x75, 0x72,
0x9e, 0x66, 0xbc, 0xba, 0x29, 0x78, 0x49, 0x77, 0x8b, 0x12, 0x77, 0x36, 0x43, 0x63, 0xe0, 0xe1,
0x0f, 0xa2, 0xf7, 0x60, 0x96, 0x6c, 0xd6, 0xb3, 0xfb, 0xde, 0x29, 0x14, 0x2f, 0x68, 0x0f, 0x3a,
0x28, 0x33, 0x39, 0x80, 0x0c, 0x26, 0x9f, 0x8f, 0xbd, 0x7a, 0x68, 0xea, 0xb9, 0x1f, 0x86, 0x5a,
0xb6, 0x77, 0x58, 0xc6, 0x48, 0xdb, 0x4a, 0xd8, 0x61, 0x5b, 0x43, 0x60, 0xbb, 0x8c, 0x7e, 0x43,
0x3f, 0x96, 0x7a, 0x1d, 0x95, 0xf2, 0x7a, 0x92, 0x5e, 0x27, 0xda, 0x6d, 0x43, 0xda, 0xd7, 0x93,
0x7e, 0x70, 0xab, 0x3d, 0x30, 0x02, 0xfd, 0xed, 0x41, 0xe3, 0xef, 0x7e, 0x18, 0x02, 0xdb, 0x7f,
0x37, 0x88, 0x7e, 0x08, 0xb2, 0x57, 0x79, 0x7c, 0x9e, 0x31, 0xb9, 0x24, 0x1e, 0x31, 0x71, 0xcd,
0xcb, 0xab, 0xf1, 0x6d, 0x9e, 0x10, 0xcb, 0xbf, 0x1f, 0xee, 0x58, 0xfe, 0x49, 0x25, 0xab, 0xe2,
0x83, 0x86, 0x0a, 0x5e, 0xe0, 0x8a, 0xaf, 0x69, 0x81, 0xe0, 0x05, 0x55, 0xf1, 0xb9, 0x48, 0xcb,
0xea, 0x61, 0x3d, 0x6d, 0xfa, 0xad, 0x1e, 0xda, 0xf3, 0xe4, 0xbd, 0x10, 0x62, 0xa6, 0xad, 0x26,
0x81, 0x79, 0x7e, 0x91, 0x4e, 0xcf, 0x8a, 0x49, 0x9d, 0xc6, 0x8f, 0xfc, 0x19, 0x6a, 0x21, 0xc4,
0xb4, 0x45, 0xa0, 0xe0, 0xed, 0x1f, 0x4c, 0x61, 0x04, 0x43, 0x69, 0xb7, 0xe4, 0xb3, 0x03, 0x36,
0x8d, 0x93, 0x5b, 0x18, 0xff, 0x9f, 0x86, 0x06, 0x1e, 0xa6, 0x75, 0x10, 0x9f, 0x2d, 0xa9, 0x05,
0xf1, 0xfc, 0xe7, 0x20, 0xba, 0xdf, 0x34, 0xff, 0x32, 0xce, 0xa7, 0x0c, 0xfa, 0x53, 0x45, 0xbf,
0x95, 0x4f, 0x4e, 0x58, 0x25, 0xe2, 0x52, 0x0c, 0x7f, 0xec, 0x6f, 0x64, 0x48, 0x47, 0xc7, 0xf6,
0x93, 0x6f, 0xa5, 0x6b, 0x7a, 0x7d, 0x5c, 0x4f, 0x6c, 0x30, 0x05, 0xb8, 0xbd, 0x2e, 0x25, 0x78,
0x02, 0xb8, 0x17, 0x42, 0x4c, 0xaf, 0x4b, 0xc1, 0x7e, 0xbe, 0x48, 0x05, 0xdb, 0x63, 0x39, 0x2b,
0xdb, 0xbd, 0xae, 0x54, 0x5d, 0x84, 0xe8, 0x75, 0x02, 0x35, 0x93, 0x8d, 0xe3, 0x4d, 0x2f, 0x8e,
0xeb, 0x01, 0x23, 0xad, 0xe5, 0xf1, 0x49, 0x3f, 0xd8, 0xec, 0xee, 0x2c, 0x9f, 0x27, 0x6c, 0xc1,
0xaf, 0xf0, 0xee, 0xce, 0x36, 0xa1, 0x00, 0x62, 0x77, 0xe7, 0x05, 0xcd, 0x0a, 0x66, 0xf9, 0x79,
0x93, 0xb2, 0x6b, 0xb4, 0x82, 0xd9, 0xca, 0xb5, 0x98, 0x58, 0xc1, 0x3c, 0x18, 0x78, 0x38, 0x8a,
0x7e, 0x49, 0x0a, 0x7f, 0x8f, 0xa7, 0xf9, 0xf0, 0xae, 0x47, 0xa9, 0x16, 0x68, 0xab, 0x1f, 0xd2,
0x00, 0x8a, 0xb8, 0xfe, 0xeb, 0x76, 0x9c, 0x27, 0x2c, 0xf3, 0x46, 0x6c, 0xc4, 0xc1, 0x88, 0x1d,
0x0c, 0x45, 0xfc, 0xea, 0x26, 0x15, 0xde, 0x88, 0x6b, 0x41, 0x30, 0x62, 0x00, 0x50, 0xb6, 0x82,
0xc6, 0x56, 0x51, 0x94, 0xf5, 0x0c, 0xe8, 0xcb, 0x56, 0x17, 0x09, 0x66, 0x6b, 0x0b, 0xf5, 0x7b,
0xdb, 0x61, 0x49, 0x96, 0xe6, 0x41, 0x6f, 0x80, 0xf4, 0xf1, 0x66, 0x50, 0xf0, 0x36, 0x8f, 0xde,
0x97, 0xc0, 0x71, 0x5c, 0x8a, 0x34, 0x49, 0x8b, 0x38, 0x6f, 0xea, 0x62, 0x5f, 0xbe, 0xb7, 0x28,
0xed, 0x73, 0xa3, 0x27, 0x0d, 0x6e, 0xff, 0x7d, 0x10, 0x7d, 0x84, 0xfd, 0x1e, 0xb3, 0x72, 0x96,
0xca, 0xed, 0x55, 0xa5, 0x26, 0xa7, 0xe1, 0xe7, 0x61, 0xa3, 0x2d, 0x05, 0x1d, 0xcd, 0x8f, 0x96,
0x57, 0x84, 0xc0, 0x7e, 0x3f, 0x8a, 0x54, 0x19, 0x2f, 0xb7, 0x5a, 0x6e, 0x6e, 0x40, 0x7d, 0xef,
0xec, 0xb3, 0x3e, 0x0a, 0x10, 0x66, 0x0a, 0x55, 0x7f, 0x97, 0x3b, 0xc8, 0xa1, 0x57, 0x43, 0x8a,
0x88, 0x29, 0x14, 0x21, 0x38, 0xd0, 0xf1, 0x25, 0xbf, 0xf6, 0x07, 0x5a, 0x4b, 0xc2, 0x81, 0x02,
0x61, 0xce, 0x74, 0x20, 0x50, 0xdf, 0x99, 0x4e, 0x13, 0x46, 0xe8, 0x4c, 0x07, 0x33, 0x60, 0x98,
0x47, 0xbf, 0x6e, 0x1b, 0x7e, 0xc9, 0xf9, 0xd5, 0x2c, 0x2e, 0xaf, 0x86, 0x8f, 0x69, 0xe5, 0x86,
0xd1, 0x8e, 0xd6, 0x7b, 0xb1, 0x66, 0x0c, 0xd9, 0x0e, 0xeb, 0x05, 0xf8, 0xac, 0xcc, 0xd0, 0x18,
0x72, 0x6c, 0x00, 0x42, 0x8c, 0x21, 0x02, 0x35, 0x33, 0x9a, 0xed, 0x6d, 0xcc, 0xf0, 0x2e, 0xc2,
0x51, 0x1f, 0x33, 0x6a, 0x17, 0xe1, 0xc1, 0x70, 0x0a, 0xed, 0x95, 0x71, 0x71, 0xe9, 0x4f, 0x21,
0x29, 0x0a, 0xa7, 0x50, 0x83, 0xe0, 0xfe, 0x1e, 0xb3, 0xb8, 0x4c, 0x2e, 0xfd, 0xfd, 0xad, 0x64,
0xe1, 0xfe, 0xd6, 0x8c, 0x59, 0x70, 0x6d, 0xc3, 0xe3, 0xf9, 0x79, 0x95, 0x94, 0xe9, 0x39, 0x1b,
0xae, 0xd3, 0xda, 0x1a, 0x22, 0x16, 0x5c, 0x12, 0x36, 0x67, 0x3e, 0xe0, 0xb3, 0x91, 0xed, 0x4f,
0x2a, 0x74, 0xe6, 0xd3, 0xd8, 0xb0, 0x08, 0xe2, 0xcc, 0xc7, 0x4f, 0xe2, 0xe6, 0xed, 0x95, 0x7c,
0x5e, 0x54, 0x1d, 0xcd, 0x43, 0x50, 0xb8, 0x79, 0x6d, 0x18, 0x7c, 0xde, 0x44, 0xbf, 0x69, 0x3f,
0xd2, 0xb3, 0xbc, 0xd2, 0x5e, 0x37, 0xe8, 0xe7, 0x64, 0x61, 0xc4, 0xe9, 0x49, 0x00, 0x37, 0x1b,
0xf1, 0xc6, 0xb3, 0xd8, 0x61, 0x22, 0x4e, 0xb3, 0x6a, 0xb8, 0xea, 0xb7, 0xd1, 0xc8, 0x89, 0x8d,
0xb8, 0x8f, 0xc3, 0x43, 0x68, 0x67, 0x5e, 0x64, 0x69, 0xd2, 0x3e, 0x46, 0x03, 0x5d, 0x2d, 0x0e,
0x0f, 0x21, 0x1b, 0xc3, 0x53, 0xc2, 0x98, 0x09, 0xf5, 0x1f, 0xa7, 0xb7, 0x05, 0xf3, 0x4f, 0x09,
0x0e, 0x12, 0x9e, 0x12, 0x30, 0x8a, 0xdb, 0x33, 0x66, 0xe2, 0x20, 0xbe, 0xe5, 0x73, 0x62, 0x4a,
0xd0, 0xe2, 0x70, 0x7b, 0x6c, 0xcc, 0x2c, 0xdc, 0xda, 0xc3, 0x7e, 0x2e, 0x58, 0x99, 0xc7, 0xd9,
0x6e, 0x16, 0x4f, 0xab, 0x21, 0x31, 0x6e, 0x5c, 0x8a, 0x58, 0xb8, 0x69, 0xda, 0xf3, 0x18, 0xf7,
0xab, 0xdd, 0x78, 0xc1, 0xcb, 0x54, 0xd0, 0x8f, 0xd1, 0x20, 0x9d, 0x8f, 0xd1, 0x41, 0xbd, 0xde,
0xb6, 0xca, 0xe4, 0x32, 0x5d, 0xb0, 0x49, 0xc0, 0x5b, 0x83, 0xf4, 0xf0, 0x66, 0xa1, 0x9e, 0x4e,
0x1b, 0xf3, 0x79, 0x99, 0x30, 0xb2, 0xd3, 0x94, 0xb8, 0xb3, 0xd3, 0x34, 0x06, 0x1e, 0xfe, 0x6a,
0x10, 0xfd, 0x96, 0x92, 0xda, 0x67, 0x5b, 0x3b, 0x71, 0x75, 0x79, 0xce, 0xe3, 0x72, 0x32, 0xfc,
0xc4, 0x67, 0xc7, 0x8b, 0x6a, 0xd7, 0xcf, 0x96, 0x51, 0xc1, 0x8f, 0xf5, 0x20, 0xad, 0xac, 0x11,
0xe7, 0x7d, 0xac, 0x0e, 0x12, 0x7e, 0xac, 0x18, 0xc5, 0x13, 0x88, 0x94, 0xab, 0x7d, 0xe4, 0x2a,
0xa9, 0xef, 0x6e, 0x26, 0xd7, 0x3a, 0x39, 0x3c, 0x3f, 0xd6, 0x42, 0x37, 0x5b, 0x36, 0x28, 0x1b,
0xfe, 0x8c, 0x19, 0xf5, 0xc5, 0x49, 0xcf, 0x7a, 0x54, 0x84, 0x3d, 0xb7, 0x46, 0xc6, 0xa8, 0x2f,
0x4e, 0x78, 0xb6, 0xa6, 0xb5, 0x90, 0x67, 0xcf, 0xd4, 0x36, 0xea, 0x8b, 0xe3, 0x04, 0xda, 0x2a,
0x8a, 0xec, 0xf6, 0x94, 0xcd, 0x8a, 0x8c, 0x4c, 0x20, 0x07, 0x09, 0x27, 0x10, 0x46, 0x71, 0xf5,
0x73, 0xca, 0xeb, 0xda, 0xca, 0x5b, 0xfd, 0x48, 0x51, 0xb8, 0xfa, 0x69, 0x10, 0x5c, 0x30, 0x9c,
0xf2, 0x6d, 0x9e, 0x65, 0x2c, 0x11, 0xed, 0x4b, 0x22, 0xad, 0x69, 0x88, 0x70, 0xc1, 0x80, 0x48,
0x73, 0x18, 0xd0, 0xd4, 0xea, 0x71, 0xc9, 0x5e, 0xde, 0x1e, 0xa4, 0xf9, 0xd5, 0xd0, 0xbf, 0x36,
0x1a, 0x80, 0x38, 0x0c, 0xf0, 0x82, 0x78, 0x4f, 0x70, 0x96, 0x4f, 0xb8, 0x7f, 0x4f, 0x50, 0x4b,
0xc2, 0x7b, 0x02, 0x20, 0xb0, 0xc9, 0x13, 0x46, 0x99, 0xac, 0x25, 0x61, 0x93, 0x40, 0xf8, 0xe6,
0x03, 0x38, 0x75, 0x23, 0xe7, 0x03, 0x74, 0xce, 0xb6, 0xd6, 0xc9, 0xe1, 0x0c, 0x6d, 0x36, 0x07,
0xbb, 0x4c, 0x24, 0x97, 0xfe, 0x0c, 0x75, 0x90, 0x70, 0x86, 0x62, 0x14, 0x37, 0xe9, 0x94, 0xeb,
0xcd, 0xcd, 0xaa, 0x3f, 0x3f, 0x5a, 0x1b, 0x9b, 0xb5, 0x4e, 0x0e, 0x97, 0xeb, 0xfb, 0x33, 0xf9,
0xcc, 0xbc, 0x49, 0xae, 0x64, 0xe1, 0x72, 0x5d, 0x33, 0x38, 0x7a, 0x25, 0xa8, 0x1f, 0xa7, 0x3f,
0x7a, 0x23, 0x0f, 0x47, 0xef, 0x70, 0xe0, 0xe4, 0x5f, 0x07, 0xd1, 0x5d, 0xdb, 0xcb, 0x11, 0xaf,
0xc7, 0xc8, 0x9b, 0x38, 0x4b, 0x27, 0xb1, 0x60, 0xa7, 0xfc, 0x8a, 0xe5, 0x68, 0xbf, 0xef, 0x46,
0xab, 0xf8, 0x91, 0xa3, 0x40, 0xec, 0xf7, 0x7b, 0x29, 0xe2, 0x3c, 0x51, 0xf4, 0x59, 0xc5, 0xb6,
0xe3, 0x8a, 0x98, 0xc9, 0x1c, 0x24, 0x9c, 0x27, 0x18, 0xc5, 0x45, 0x9b, 0x92, 0xbf, 0xba, 0x29,
0x58, 0x99, 0xb2, 0x3c, 0x61, 0xfe, 0xa2, 0x0d, 0x53, 0xe1, 0xa2, 0xcd, 0x43, 0xb7, 0xb6, 0xc3,
0x7a, 0x72, 0x6a, 0xdf, 0xf3, 0x62, 0x22, 0x70, 0xcf, 0x4b, 0xa0, 0xb8, 0x91, 0x06, 0xf0, 0x1e,
0x29, 0xb5, 0xac, 0x04, 0x8f, 0x94, 0x68, 0xba, 0x75, 0xc8, 0xa0, 0x99, 0x71, 0x3d, 0x4c, 0x3a,
0x42, 0x1f, 0xdb, 0xc3, 0x65, 0xbd, 0x17, 0xeb, 0x3f, 0xd5, 0x38, 0x61, 0x59, 0x2c, 0x97, 0x90,
0xc0, 0xd1, 0x41, 0xc3, 0xf4, 0x39, 0xd5, 0xb0, 0x58, 0x70, 0xf8, 0x17, 0x83, 0xe8, 0x8e, 0xcf,
0xe3, 0xeb, 0x42, 0xfa, 0x7d, 0xda, 0x6d, 0x4b, 0x91, 0xc4, 0x45, 0x76, 0x58, 0x03, 0x62, 0xf8,
0x93, 0xe8, 0x83, 0x46, 0x64, 0xee, 0xb9, 0x21, 0x00, 0xb7, 0x8a, 0xd0, 0xf1, 0x63, 0x4e, 0xbb,
0xdf, 0xec, 0xcd, 0x9b, 0x02, 0xdd, 0x8d, 0xab, 0x42, 0x05, 0xba, 0xb6, 0x01, 0x62, 0xa2, 0x40,
0xf7, 0x60, 0x78, 0xa5, 0x6e, 0x90, 0x7a, 0x9c, 0xf8, 0xe6, 0x38, 0x6d, 0xc2, 0x1e, 0x25, 0x0f,
0xbb, 0x41, 0x9c, 0x3b, 0x8d, 0x18, 0xea, 0xe2, 0xc7, 0x21, 0x0b, 0xa8, 0x36, 0x5e, 0xef, 0xc5,
0x82, 0xc3, 0x3f, 0x8b, 0xbe, 0xdf, 0x6a, 0xd8, 0x2e, 0x8b, 0xc5, 0xbc, 0x64, 0x93, 0xe1, 0x66,
0x47, 0xdc, 0x0d, 0xa8, 0x5d, 0x3f, 0xed, 0xaf, 0x00, 0xfe, 0xff, 0x66, 0x10, 0xfd, 0xc0, 0xe5,
0x54, 0x17, 0xeb, 0x18, 0x9e, 0x85, 0x4c, 0xba, 0xac, 0x0e, 0xe3, 0xf9, 0x52, 0x3a, 0xad, 0x3d,
0x98, 0x9d, 0xc8, 0x5b, 0x8b, 0x38, 0xcd, 0xe2, 0xf3, 0x8c, 0x79, 0xf7, 0x60, 0x4e, 0x6e, 0x6a,
0x34, 0xb8, 0x07, 0x23, 0x55, 0x5a, 0xb3, 0xa4, 0x1c, 0x6f, 0x56, 0xed, 0xfe, 0x84, 0x1e, 0x95,
0x9e, 0xd2, 0x7d, 0xa3, 0x27, 0x0d, 0x6e, 0x45, 0x73, 0x76, 0x55, 0xff, 0xd9, 0x4e, 0x72, 0x9f,
0x57, 0x50, 0xf5, 0x64, 0xfa, 0x46, 0x4f, 0x1a, 0xbc, 0xfe, 0x69, 0xf4, 0x41, 0xdb, 0x2b, 0x2c,
0x0a, 0x9b, 0x9d, 0xa6, 0xd0, 0xba, 0xf0, 0xb4, 0xbf, 0x82, 0x29, 0xf5, 0xbf, 0x48, 0x2b, 0xc1,
0xcb, 0xdb, 0xf1, 0x25, 0xbf, 0x6e, 0xde, 0xe5, 0x74, 0x47, 0x2b, 0x00, 0x23, 0x8b, 0x20, 0x4a,
0x7d, 0x3f, 0xd9, 0x72, 0x65, 0xde, 0xf9, 0xac, 0x08, 0x57, 0x16, 0xd1, 0xe1, 0xca, 0x25, 0xcd,
0x5c, 0xd5, 0xb4, 0xca, 0xbc, 0xa0, 0xba, 0xe6, 0x0f, 0xb5, 0xfd, 0x92, 0xea, 0xc3, 0x6e, 0xd0,
0x6c, 0xbf, 0x76, 0xd3, 0x8c, 0xbd, 0xbe, 0xb8, 0xc8, 0x78, 0x3c, 0x41, 0xdb, 0xaf, 0x5a, 0x32,
0x02, 0x11, 0xb1, 0xfd, 0x42, 0x88, 0x29, 0x3a, 0x6b, 0x81, 0xbc, 0x9b, 0x69, 0x4c, 0xaf, 0xb6,
0xf5, 0x6c, 0x39, 0x51, 0x74, 0xfa, 0x38, 0xb3, 0x60, 0xd4, 0xd2, 0x7a, 0x08, 0x36, 0x3e, 0x1e,
0xb4, 0x75, 0x2d, 0x31, 0xb1, 0x60, 0x78, 0x30, 0xb3, 0x3f, 0xaa, 0x85, 0x67, 0x85, 0x34, 0xfe,
0x61, 0x5b, 0x4b, 0x49, 0x88, 0xfd, 0x91, 0x4b, 0x98, 0x3a, 0xbf, 0xfe, 0xfb, 0x0e, 0xbf, 0xce,
0xa5, 0x51, 0xcf, 0xd3, 0x6c, 0x64, 0x44, 0x9d, 0x8f, 0x19, 0x30, 0xfc, 0xd3, 0xe8, 0x17, 0xa5,
0xe1, 0x92, 0x17, 0xc3, 0x15, 0x8f, 0x42, 0x69, 0xbd, 0x11, 0x72, 0x97, 0x94, 0x9b, 0x17, 0x9b,
0x74, 0xff, 0x9d, 0x55, 0xf1, 0x94, 0xa1, 0x17, 0x9b, 0x4c, 0xaf, 0x48, 0x29, 0xf1, 0x62, 0x53,
0x9b, 0x32, 0x2f, 0xeb, 0xd4, 0xb2, 0x23, 0x3e, 0x01, 0xeb, 0x9e, 0x16, 0x6a, 0x21, 0xf1, 0xb2,
0x4e, 0x0b, 0x32, 0xe7, 0xf7, 0x47, 0xf1, 0x22, 0x9d, 0xea, 0xc9, 0x5f, 0xcd, 0x21, 0x15, 0x3a,
0xbf, 0x37, 0xcc, 0xc8, 0x82, 0x88, 0xf3, 0x7b, 0x12, 0x06, 0x9f, 0xff, 0x32, 0x88, 0x3e, 0x34,
0xcc, 0x5e, 0x73, 0xac, 0xb2, 0x9f, 0x5f, 0xf0, 0xb7, 0xa9, 0xb8, 0xac, 0xf7, 0xf1, 0xd5, 0xf0,
0x05, 0x65, 0xd2, 0xcf, 0xeb, 0x50, 0x3e, 0x5f, 0x5a, 0xcf, 0x54, 0x73, 0xcd, 0x71, 0x8b, 0xb9,
0xdb, 0x52, 0x1a, 0xa8, 0x9a, 0xd3, 0xa7, 0x32, 0x98, 0x23, 0xaa, 0xb9, 0x10, 0x6f, 0xba, 0x58,
0x3b, 0xcf, 0x78, 0x8e, 0xbb, 0xd8, 0x58, 0xa8, 0x85, 0x44, 0x17, 0xb7, 0x20, 0x33, 0x37, 0x36,
0x22, 0x75, 0x32, 0xb0, 0x95, 0x65, 0x68, 0x6e, 0xd4, 0xaa, 0x1a, 0x20, 0xe6, 0x46, 0x2f, 0x08,
0x7e, 0x4e, 0xa2, 0xef, 0xd4, 0x8f, 0xf4, 0xb8, 0x64, 0x8b, 0x94, 0xe1, 0x6b, 0x58, 0x4b, 0x42,
0x8c, 0x7f, 0x97, 0x30, 0x23, 0xeb, 0x2c, 0xaf, 0x8a, 0x2c, 0xae, 0x2e, 0xe1, 0x62, 0xce, 0x6d,
0x73, 0x23, 0xc4, 0x57, 0x73, 0x0f, 0x3a, 0x28, 0x33, 0xf1, 0x36, 0x32, 0x3d, 0xc5, 0xac, 0xfa,
0x55, 0x5b, 0xd3, 0xcc, 0x5a, 0x27, 0x67, 0x8e, 0x26, 0xf7, 0xe2, 0x2c, 0x63, 0xe5, 0x6d, 0x23,
0x3b, 0x8c, 0xf3, 0xf4, 0x82, 0x55, 0x02, 0x1d, 0x4d, 0x02, 0x35, 0xc2, 0x18, 0x71, 0x34, 0x19,
0xc0, 0x4d, 0x65, 0x8d, 0x3c, 0xef, 0xe7, 0x13, 0x76, 0x83, 0x2a, 0x6b, 0x6c, 0x47, 0x32, 0x44,
0x65, 0x4d, 0xb1, 0x66, 0x79, 0x7c, 0x99, 0xf1, 0xe4, 0x0a, 0x96, 0x00, 0xb7, 0x83, 0xa5, 0x04,
0xaf, 0x01, 0xf7, 0x42, 0x88, 0x59, 0x04, 0xa4, 0xe0, 0x84, 0x15, 0x59, 0x9c, 0xe0, 0xbb, 0x78,
0xa5, 0x03, 0x32, 0x62, 0x11, 0xc0, 0x0c, 0x0a, 0x17, 0xee, 0xf8, 0x7d, 0xe1, 0xa2, 0x2b, 0xfe,
0x7b, 0x21, 0xc4, 0x2c, 0x83, 0x52, 0x30, 0x2e, 0xb2, 0x54, 0xa0, 0x61, 0xa0, 0x34, 0xa4, 0x84,
0x18, 0x06, 0x2e, 0x81, 0x4c, 0x1e, 0xb2, 0x72, 0xca, 0xbc, 0x26, 0xa5, 0x24, 0x68, 0xb2, 0x21,
0xcc, 0x8b, 0x41, 0xaa, 0xed, 0xbc, 0xb8, 0x45, 0x2f, 0x06, 0x41, 0xb3, 0x78, 0x71, 0x4b, 0xbc,
0x18, 0xe4, 0x00, 0x28, 0xc4, 0xe3, 0xb8, 0x12, 0xfe, 0x10, 0xa5, 0x24, 0x18, 0x62, 0x43, 0x98,
0x35, 0x5a, 0x85, 0x38, 0x17, 0x68, 0x8d, 0x86, 0x00, 0xac, 0xab, 0xc2, 0xbb, 0xa4, 0xdc, 0xcc,
0x24, 0xaa, 0x57, 0x98, 0xd8, 0x4d, 0x59, 0x36, 0xa9, 0xd0, 0x4c, 0x02, 0xcf, 0xbd, 0x91, 0x12,
0x33, 0x49, 0x9b, 0x42, 0xa9, 0x04, 0x67, 0xb8, 0xbe, 0xd6, 0xa1, 0xe3, 0xdb, 0x7b, 0x21, 0xc4,
0xcc, 0x4f, 0x4d, 0xd0, 0xdb, 0x71, 0x59, 0xa6, 0xf5, 0xe2, 0xbf, 0xea, 0x0f, 0xa8, 0x91, 0x13,
0xf3, 0x93, 0x8f, 0x43, 0xc3, 0xab, 0x99, 0xb8, 0x7d, 0x81, 0xe1, 0xa9, 0xfb, 0xe3, 0x20, 0x63,
0x2a, 0x4e, 0x29, 0xb1, 0xee, 0xba, 0x7c, 0x4f, 0xd3, 0x73, 0xd5, 0xb5, 0xda, 0x85, 0x59, 0xaf,
0x1a, 0x6b, 0x17, 0x87, 0x7c, 0xc1, 0x4e, 0xf9, 0xab, 0x9b, 0xb4, 0x12, 0x69, 0x3e, 0x85, 0x95,
0xfb, 0x39, 0x61, 0xc9, 0x07, 0x13, 0xaf, 0x1a, 0x77, 0x2a, 0x99, 0x02, 0x02, 0xc5, 0x72, 0xc4,
0xae, 0xbd, 0x05, 0x04, 0xb6, 0xa8, 0x39, 0xa2, 0x80, 0x08, 0xf1, 0xe6, 0x4c, 0x43, 0x3b, 0x87,
0xdf, 0x63, 0x9d, 0xf2, 0xa6, 0x96, 0xa3, 0xac, 0x61, 0x90, 0xd8, 0x56, 0x06, 0x15, 0xcc, 0x5e,
0x4f, 0xfb, 0x37, 0x43, 0xec, 0x21, 0x61, 0xa7, 0x3d, 0xcc, 0x1e, 0xf5, 0x20, 0x3d, 0xae, 0xcc,
0x85, 0x2d, 0xe5, 0xaa, 0x7d, 0x5f, 0xfb, 0xa8, 0x07, 0x69, 0x9d, 0x8f, 0xd8, 0xcd, 0x7a, 0x19,
0x27, 0x57, 0xd3, 0x92, 0xcf, 0xf3, 0xc9, 0x36, 0xcf, 0x78, 0x89, 0xce, 0x47, 0x9c, 0xa8, 0x11,
0x4a, 0x9c, 0x8f, 0x74, 0xa8, 0x98, 0x0a, 0xce, 0x8e, 0x62, 0x2b, 0x4b, 0xa7, 0x78, 0x77, 0xeb,
0x18, 0x92, 0x00, 0x51, 0xc1, 0x79, 0x41, 0x4f, 0x12, 0xa9, 0xdd, 0xaf, 0x48, 0x93, 0x38, 0x53,
0xfe, 0x36, 0x69, 0x33, 0x0e, 0xd8, 0x99, 0x44, 0x1e, 0x05, 0x4f, 0x3b, 0x4f, 0xe7, 0x65, 0xbe,
0x9f, 0x0b, 0x4e, 0xb6, 0xb3, 0x01, 0x3a, 0xdb, 0x69, 0x81, 0x68, 0x5a, 0x3d, 0x65, 0x37, 0x75,
0x34, 0xf5, 0x3f, 0xbe, 0x69, 0xb5, 0xfe, 0xfb, 0x08, 0xe4, 0xa1, 0x69, 0x15, 0x71, 0xa8, 0x31,
0xe0, 0x44, 0x25, 0x4c, 0x40, 0xdb, 0x4d, 0x93, 0x87, 0xdd, 0xa0, 0xdf, 0xcf, 0x58, 0xdc, 0x66,
0x2c, 0xe4, 0x47, 0x02, 0x7d, 0xfc, 0x34, 0xa0, 0xb9, 0x38, 0x71, 0xda, 0x73, 0xc9, 0x92, 0xab,
0xd6, 0xfb, 0x27, 0x6e, 0xa0, 0x0a, 0x21, 0x2e, 0x4e, 0x08, 0xd4, 0xdf, 0x45, 0xfb, 0x09, 0xcf,
0x43, 0x5d, 0x54, 0xcb, 0xfb, 0x74, 0x11, 0x70, 0x66, 0xf3, 0xab, 0xa5, 0x90, 0x99, 0xaa, 0x9b,
0xd6, 0x09, 0x0b, 0x36, 0x44, 0x6c, 0x7e, 0x49, 0xd8, 0xd4, 0xe4, 0xd8, 0xe7, 0x61, 0xfb, 0xfd,
0xcf, 0x96, 0x95, 0x43, 0xfa, 0xfd, 0x4f, 0x8a, 0xa5, 0x1b, 0xa9, 0x72, 0xa4, 0xc3, 0x8a, 0x9b,
0x27, 0x4f, 0xfa, 0xc1, 0x66, 0xcb, 0xe3, 0xf8, 0xdc, 0xce, 0x58, 0x5c, 0x2a, 0xaf, 0x1b, 0x01,
0x43, 0x06, 0x23, 0xb6, 0x3c, 0x01, 0x1c, 0x4d, 0x61, 0x8e, 0xe7, 0x6d, 0x9e, 0x0b, 0x96, 0x0b,
0xdf, 0x14, 0xe6, 0x1a, 0x03, 0x30, 0x34, 0x85, 0x51, 0x0a, 0x28, 0x6f, 0xe5, 0x79, 0x10, 0x13,
0x47, 0xf1, 0xcc, 0x5b, 0xb1, 0xa9, 0xb3, 0x1e, 0x25, 0x0f, 0xe5, 0x2d, 0xe2, 0xd0, 0x90, 0xdf,
0x9f, 0xc5, 0x53, 0xed, 0xc5, 0xa3, 0x2d, 0xe5, 0x2d, 0x37, 0x0f, 0xbb, 0x41, 0xe4, 0xe7, 0x4d,
0x3a, 0x61, 0x3c, 0xe0, 0x47, 0xca, 0xfb, 0xf8, 0xc1, 0x20, 0xaa, 0x9c, 0xea, 0xd6, 0xaa, 0xdd,
0xd4, 0x56, 0x3e, 0x81, 0x3d, 0xe4, 0x88, 0x78, 0x28, 0x88, 0x0b, 0x55, 0x4e, 0x04, 0x8f, 0xc6,
0x47, 0x73, 0x38, 0x1a, 0x1a, 0x1f, 0xfa, 0xec, 0xb3, 0xcf, 0xf8, 0xf0, 0xc1, 0xe0, 0xf3, 0x8f,
0x61, 0x7c, 0xec, 0xc4, 0x22, 0xae, 0x6b, 0xe6, 0x37, 0x29, 0xbb, 0x86, 0x4d, 0xa8, 0xa7, 0xbd,
0x0d, 0x35, 0x92, 0x3f, 0x46, 0x41, 0x3b, 0xd2, 0xcd, 0xde, 0x7c, 0xc0, 0x37, 0x54, 0xe7, 0x9d,
0xbe, 0x51, 0x99, 0xbe, 0xd9, 0x9b, 0x0f, 0xf8, 0x86, 0x5f, 0xb9, 0x75, 0xfa, 0x46, 0x3f, 0x75,
0xdb, 0xec, 0xcd, 0x83, 0xef, 0xbf, 0x1c, 0x44, 0x77, 0x5a, 0xce, 0xeb, 0x1a, 0x28, 0x11, 0xe9,
0x82, 0xf9, 0x4a, 0x39, 0xd7, 0x9e, 0x46, 0x43, 0xa5, 0x1c, 0xad, 0x62, 0x7d, 0x1a, 0xc1, 0x17,
0xc5, 0x31, 0xaf, 0x52, 0x79, 0x71, 0xfc, 0xbc, 0x87, 0xd1, 0x06, 0x0e, 0x6d, 0x58, 0x42, 0x4a,
0xe6, 0xda, 0xcd, 0x41, 0xcd, 0xab, 0x9e, 0x4f, 0x02, 0xf6, 0xda, 0x6f, 0x7c, 0x6e, 0xf4, 0xa4,
0xcd, 0x05, 0x98, 0xc3, 0xd8, 0x37, 0x6f, 0xa1, 0x5e, 0xf5, 0x5e, 0xbe, 0x3d, 0xed, 0xaf, 0x00,
0xee, 0xff, 0xba, 0xa9, 0xe9, 0xb1, 0x7f, 0x18, 0x04, 0xcf, 0xfa, 0x58, 0x44, 0x03, 0xe1, 0xf9,
0x52, 0x3a, 0x10, 0xc8, 0x7f, 0x0c, 0xa2, 0x7b, 0xde, 0x40, 0xdc, 0x3b, 0xd8, 0xdf, 0xee, 0x63,
0xdb, 0x7f, 0x17, 0xfb, 0xe3, 0x6f, 0xa3, 0x0a, 0xd1, 0xfd, 0x7d, 0xb3, 0xb5, 0x6e, 0x34, 0xe4,
0xeb, 0xf8, 0xaf, 0xcb, 0x09, 0x2b, 0x61, 0xc4, 0x86, 0x92, 0xce, 0xc0, 0x78, 0xdc, 0x7e, 0xb6,
0xa4, 0x96, 0xf5, 0x19, 0x0f, 0x07, 0x86, 0x5f, 0x26, 0x59, 0xf1, 0x84, 0x2c, 0x5b, 0x34, 0x0e,
0xe8, 0xc5, 0xb2, 0x6a, 0xd4, 0x48, 0xb6, 0x60, 0xf9, 0xab, 0xe0, 0xe7, 0x3d, 0x0d, 0x3b, 0xbf,
0x13, 0xfe, 0x74, 0x39, 0x25, 0x88, 0xe5, 0xbf, 0x06, 0xd1, 0x03, 0x87, 0x35, 0x37, 0x0d, 0xe8,
0x3c, 0xe4, 0x27, 0x01, 0xfb, 0x94, 0x92, 0x0e, 0xee, 0x77, 0xbe, 0x9d, 0xb2, 0xf9, 0xe6, 0x85,
0xa3, 0xb2, 0x9b, 0x66, 0x82, 0x95, 0xed, 0x6f, 0x5e, 0xb8, 0x76, 0x15, 0x35, 0xa2, 0xbf, 0x79,
0x11, 0xc0, 0xad, 0x6f, 0x5e, 0x78, 0x3c, 0x7b, 0xbf, 0x79, 0xe1, 0xb5, 0x16, 0xfc, 0xe6, 0x45,
0x58, 0x83, 0x5a, 0x7c, 0x9a, 0x10, 0xd4, 0x89, 0x76, 0x2f, 0x8b, 0xee, 0x01, 0xf7, 0xb3, 0x65,
0x54, 0x88, 0xe5, 0x57, 0x71, 0xf2, 0xcd, 0xb0, 0x1e, 0xcf, 0xd4, 0x79, 0x3b, 0x6c, 0xb3, 0x37,
0x0f, 0xbe, 0x7f, 0x06, 0xfb, 0x1e, 0xbd, 0xd8, 0xf0, 0x52, 0x7e, 0xef, 0x64, 0x3d, 0xb4, 0x78,
0xd4, 0x16, 0xec, 0x9e, 0x7f, 0xd2, 0x0f, 0x26, 0x9a, 0x5b, 0x13, 0xd0, 0xe9, 0xa3, 0x2e, 0x43,
0xa8, 0xcb, 0x37, 0x7b, 0xf3, 0xc4, 0x22, 0xa7, 0x7c, 0xab, 0xde, 0xee, 0x61, 0xcc, 0xed, 0xeb,
0xa7, 0xfd, 0x15, 0xcc, 0xab, 0x2d, 0x2d, 0xf7, 0xb2, 0x9f, 0x3b, 0x9f, 0xa0, 0xd3, 0xcb, 0x1b,
0x3d, 0xe9, 0x50, 0x71, 0x63, 0x2f, 0xef, 0x5d, 0xc5, 0x8d, 0x77, 0x89, 0xff, 0x74, 0x39, 0x25,
0x88, 0xe5, 0x9f, 0x07, 0xd1, 0x5d, 0x32, 0x16, 0xc8, 0x82, 0x17, 0x7d, 0x2d, 0xa3, 0x6c, 0xf8,
0x7c, 0x69, 0x3d, 0x08, 0xea, 0xdf, 0x06, 0xd1, 0x87, 0x81, 0xa0, 0x54, 0x7a, 0x2c, 0x61, 0xdd,
0x4d, 0x93, 0x1f, 0x2d, 0xaf, 0x48, 0x2d, 0xf6, 0x36, 0x3e, 0x6e, 0x7f, 0x0a, 0x22, 0x60, 0x7b,
0x4c, 0x7f, 0x0a, 0xa2, 0x5b, 0x0b, 0x1f, 0xfe, 0xd4, 0x25, 0x09, 0xec, 0x8b, 0x7c, 0x87, 0x3f,
0xb2, 0x62, 0x41, 0xfb, 0xa1, 0xb5, 0x4e, 0xce, 0xe7, 0xe4, 0xd5, 0x4d, 0x11, 0xe7, 0x13, 0xda,
0x89, 0x92, 0x77, 0x3b, 0xd1, 0x1c, 0x3e, 0x34, 0xab, 0xa5, 0x27, 0xbc, 0xd9, 0xe4, 0x3d, 0xa2,
0xf4, 0x35, 0x12, 0x3c, 0x34, 0x6b, 0xa1, 0x84, 0x37, 0xa8, 0x68, 0x43, 0xde, 0x50, 0x21, 0xfb,
0xb8, 0x0f, 0x8a, 0xb6, 0x0f, 0xda, 0x9b, 0x3e, 0x8b, 0x7f, 0x12, 0xb2, 0xd2, 0x3a, 0x8f, 0xdf,
0xe8, 0x49, 0x13, 0x6e, 0xc7, 0x4c, 0x7c, 0xc1, 0xe2, 0x09, 0x2b, 0x83, 0x6e, 0x35, 0xd5, 0xcb,
0xad, 0x4d, 0xfb, 0xdc, 0x6e, 0xf3, 0x6c, 0x3e, 0xcb, 0xa1, 0x33, 0x49, 0xb7, 0x36, 0xd5, 0xed,
0x16, 0xd1, 0xf8, 0xb8, 0xd0, 0xb8, 0x95, 0xc5, 0xe5, 0xe3, 0xb0, 0x19, 0xa7, 0xa6, 0x5c, 0xef,
0xc5, 0xd2, 0xed, 0x84, 0x34, 0xea, 0x68, 0x27, 0xca, 0xa4, 0x8d, 0x9e, 0x34, 0x3e, 0xb7, 0xb3,
0xdc, 0xea, 0x7c, 0xda, 0xec, 0xb0, 0xd5, 0x4a, 0xa9, 0xa7, 0xfd, 0x15, 0xf0, 0x29, 0x29, 0x64,
0x55, 0xbd, 0x2b, 0xda, 0x4d, 0xb3, 0x6c, 0xb8, 0x1e, 0x48, 0x93, 0x06, 0x0a, 0x9e, 0x92, 0x7a,
0x60, 0x22, 0x93, 0x9b, 0x53, 0xc5, 0x7c, 0xd8, 0x65, 0x47, 0x52, 0xbd, 0x32, 0xd9, 0xa6, 0xd1,
0x69, 0x9b, 0xf5, 0xa8, 0x75, 0x6b, 0x47, 0xe1, 0x07, 0xd7, 0x6a, 0xf0, 0x66, 0x6f, 0x1e, 0x5d,
0xc3, 0x4b, 0x4a, 0xae, 0x2c, 0xf7, 0x29, 0x13, 0xce, 0x4a, 0xf2, 0xa0, 0x83, 0x42, 0x27, 0x96,
0x6a, 0x18, 0xbd, 0x4d, 0x27, 0x53, 0x26, 0xbc, 0x37, 0x48, 0x36, 0x10, 0xbc, 0x41, 0x42, 0x20,
0xea, 0x3a, 0xf5, 0xf7, 0x31, 0x13, 0xa7, 0x71, 0x39, 0x65, 0x62, 0x7f, 0xe2, 0xeb, 0x3a, 0x50,
0xb6, 0xa8, 0x50, 0xd7, 0x79, 0x69, 0x34, 0x1b, 0x68, 0xb7, 0xf0, 0x7b, 0xea, 0xc7, 0x21, 0x33,
0xe8, 0x47, 0xd5, 0xeb, 0xbd, 0x58, 0xb4, 0xa2, 0x18, 0x87, 0xe9, 0x2c, 0x15, 0xbe, 0x15, 0xc5,
0xb2, 0x51, 0x23, 0xa1, 0x15, 0xa5, 0x8d, 0x52, 0xcd, 0xab, 0x6b, 0x84, 0xfd, 0x49, 0xb8, 0x79,
0x8a, 0xe9, 0xd7, 0x3c, 0xcd, 0xb6, 0x2e, 0x3c, 0x73, 0x9d, 0x32, 0xe2, 0x12, 0xb6, 0xca, 0x9e,
0xdc, 0x96, 0x3f, 0x31, 0xc4, 0x60, 0x68, 0xd6, 0xa1, 0x14, 0xac, 0x5f, 0xb1, 0x68, 0xae, 0xb9,
0x93, 0x2d, 0x0a, 0x16, 0x97, 0x71, 0x9e, 0x78, 0xb7, 0xa6, 0xd2, 0x60, 0x8b, 0x0c, 0x6d, 0x4d,
0x49, 0x0d, 0x74, 0x9d, 0xee, 0xfe, 0x38, 0xd0, 0x33, 0x14, 0xf4, 0xaf, 0xf0, 0xdc, 0xdf, 0x06,
0x3e, 0xea, 0x41, 0xe2, 0xeb, 0xf4, 0x06, 0xd0, 0x87, 0xf2, 0xca, 0xe9, 0x27, 0x01, 0x53, 0x2e,
0x1a, 0xda, 0x06, 0xd3, 0x2a, 0x28, 0xa9, 0x75, 0x81, 0xcb, 0xc4, 0x4f, 0xd9, 0xad, 0x2f, 0xa9,
0x4d, 0x7d, 0x2a, 0x91, 0x50, 0x52, 0xb7, 0x51, 0x54, 0x67, 0xda, 0xfb, 0xa0, 0xd5, 0x80, 0xbe,
0xbd, 0xf5, 0x59, 0xeb, 0xe4, 0xd0, 0xc8, 0xd9, 0x49, 0x17, 0xce, 0x1d, 0x86, 0x27, 0xd0, 0x9d,
0x74, 0xe1, 0xbf, 0xc2, 0x58, 0xef, 0xc5, 0xe2, 0xab, 0xfa, 0x58, 0xb0, 0x9b, 0xe6, 0x0e, 0xdd,
0x13, 0xae, 0x94, 0xb7, 0x2e, 0xd1, 0x1f, 0x76, 0x83, 0xe6, 0xc5, 0xd8, 0xe3, 0x92, 0x27, 0xac,
0xaa, 0xe0, 0xfb, 0x58, 0xee, 0x9b, 0x47, 0x20, 0x1b, 0xa1, 0xaf, 0x63, 0xdd, 0x0f, 0x43, 0x60,
0xfb, 0x8b, 0xe8, 0xdd, 0x03, 0x3e, 0x1d, 0xb3, 0x7c, 0x32, 0xfc, 0xa1, 0xfb, 0x2a, 0x2a, 0x9f,
0x8e, 0xea, 0x3f, 0x6b, 0x7b, 0x2b, 0x94, 0xd8, 0xbc, 0x4c, 0xb7, 0xc3, 0xce, 0xe7, 0xd3, 0xd3,
0x92, 0x31, 0xf4, 0x32, 0x9d, 0xfc, 0xfb, 0xa8, 0x16, 0x10, 0x2f, 0xd3, 0x39, 0x80, 0x59, 0x25,
0xb5, 0xbd, 0xba, 0x10, 0xc5, 0x2f, 0xab, 0x19, 0x1d, 0x29, 0x25, 0x56, 0xc9, 0x36, 0x65, 0x3a,
0x4f, 0xca, 0xe4, 0xcb, 0xe6, 0xe3, 0xf9, 0x6c, 0x16, 0x97, 0xb7, 0xa8, 0xf3, 0x94, 0xae, 0x0d,
0x10, 0x9d, 0xe7, 0x05, 0x4d, 0x56, 0x2a, 0x3f, 0x22, 0x4e, 0xae, 0xf6, 0x78, 0xc9, 0xe7, 0x22,
0xcd, 0x59, 0x85, 0xb2, 0x12, 0x2c, 0xb8, 0x0c, 0x91, 0x95, 0x14, 0x6b, 0xaa, 0x38, 0x49, 0xa8,
0xf7, 0xe8, 0xe4, 0x57, 0x21, 0x2b, 0xc1, 0x4b, 0x7c, 0x97, 0xa7, 0xac, 0x60, 0x88, 0xa8, 0xe2,
0x48, 0x18, 0xf5, 0xfd, 0x71, 0x9a, 0x4f, 0xbd, 0x7d, 0x5f, 0x0b, 0x82, 0x7d, 0x0f, 0x80, 0x99,
0x8f, 0xd5, 0x43, 0x53, 0x9f, 0x9f, 0x81, 0xdf, 0xf6, 0x79, 0x1f, 0xba, 0x4d, 0x10, 0xf3, 0xb1,
0x9f, 0x44, 0xae, 0x5e, 0x17, 0x2c, 0x67, 0x93, 0xe6, 0x6d, 0x31, 0x9f, 0x2b, 0x87, 0x08, 0xba,
0xc2, 0xa4, 0x49, 0x85, 0x43, 0x26, 0xca, 0x34, 0xa9, 0xc6, 0x4c, 0x1c, 0xc7, 0x65, 0x3c, 0x63,
0x82, 0x95, 0x38, 0x15, 0x00, 0x19, 0x39, 0x0c, 0x91, 0x0a, 0x14, 0x0b, 0x0e, 0x7f, 0x37, 0xfa,
0x5e, 0x3d, 0x73, 0xb1, 0x1c, 0x3e, 0x53, 0xfd, 0x4a, 0x7e, 0xdf, 0x7e, 0xf8, 0xbe, 0xb6, 0x31,
0x16, 0x25, 0x8b, 0x67, 0x8d, 0xed, 0xf7, 0xf4, 0xdf, 0x25, 0xf8, 0x74, 0x50, 0xcf, 0xdb, 0x47,
0x5c, 0xa4, 0x17, 0xf5, 0x46, 0x01, 0x2e, 0x65, 0xd0, 0xbc, 0x6d, 0x8b, 0x47, 0x81, 0x5f, 0x82,
0xfb, 0x38, 0x33, 0x12, 0x6d, 0xe9, 0x09, 0x2b, 0x32, 0x3c, 0x12, 0x1d, 0x6d, 0x09, 0x10, 0x23,
0xd1, 0x0b, 0x2a, 0x3f, 0x2f, 0x3f, 0xfa, 0x9f, 0xaf, 0x57, 0x06, 0x5f, 0x7d, 0xbd, 0x32, 0xf8,
0xff, 0xaf, 0x57, 0x06, 0xff, 0xf4, 0xcd, 0xca, 0x3b, 0x5f, 0x7d, 0xb3, 0xf2, 0xce, 0xff, 0x7d,
0xb3, 0xf2, 0xce, 0x97, 0xef, 0xc2, 0xff, 0x34, 0xe0, 0xfc, 0x17, 0xe4, 0xa7, 0xff, 0x9f, 0xff,
0x3c, 0x00, 0x00, 0xff, 0xff, 0xbf, 0xc7, 0x5f, 0x26, 0x58, 0x60, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -455,7 +456,8 @@ type ClientCommandsClient interface {
// UnsplashDownload downloads picture from unsplash by ID, put it to the IPFS and returns the hash.
// The artist info is available in the object details
UnsplashDownload(ctx context.Context, in *pb.RpcUnsplashDownloadRequest, opts ...grpc.CallOption) (*pb.RpcUnsplashDownloadResponse, error)
DownloadManifest(ctx context.Context, in *pb.RpcDownloadManifestRequest, opts ...grpc.CallOption) (*pb.RpcDownloadManifestResponse, error)
GalleryDownloadManifest(ctx context.Context, in *pb.RpcGalleryDownloadManifestRequest, opts ...grpc.CallOption) (*pb.RpcGalleryDownloadManifestResponse, error)
GalleryDownloadIndex(ctx context.Context, in *pb.RpcGalleryDownloadIndexRequest, opts ...grpc.CallOption) (*pb.RpcGalleryDownloadIndexResponse, error)
// General Block commands
// ***
BlockUpload(ctx context.Context, in *pb.RpcBlockUploadRequest, opts ...grpc.CallOption) (*pb.RpcBlockUploadResponse, error)
@ -1646,9 +1648,18 @@ func (c *clientCommandsClient) UnsplashDownload(ctx context.Context, in *pb.RpcU
return out, nil
}
func (c *clientCommandsClient) DownloadManifest(ctx context.Context, in *pb.RpcDownloadManifestRequest, opts ...grpc.CallOption) (*pb.RpcDownloadManifestResponse, error) {
out := new(pb.RpcDownloadManifestResponse)
err := c.cc.Invoke(ctx, "/anytype.ClientCommands/DownloadManifest", in, out, opts...)
func (c *clientCommandsClient) GalleryDownloadManifest(ctx context.Context, in *pb.RpcGalleryDownloadManifestRequest, opts ...grpc.CallOption) (*pb.RpcGalleryDownloadManifestResponse, error) {
out := new(pb.RpcGalleryDownloadManifestResponse)
err := c.cc.Invoke(ctx, "/anytype.ClientCommands/GalleryDownloadManifest", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *clientCommandsClient) GalleryDownloadIndex(ctx context.Context, in *pb.RpcGalleryDownloadIndexRequest, opts ...grpc.CallOption) (*pb.RpcGalleryDownloadIndexResponse, error) {
out := new(pb.RpcGalleryDownloadIndexResponse)
err := c.cc.Invoke(ctx, "/anytype.ClientCommands/GalleryDownloadIndex", in, out, opts...)
if err != nil {
return nil, err
}
@ -2751,7 +2762,8 @@ type ClientCommandsServer interface {
// UnsplashDownload downloads picture from unsplash by ID, put it to the IPFS and returns the hash.
// The artist info is available in the object details
UnsplashDownload(context.Context, *pb.RpcUnsplashDownloadRequest) *pb.RpcUnsplashDownloadResponse
DownloadManifest(context.Context, *pb.RpcDownloadManifestRequest) *pb.RpcDownloadManifestResponse
GalleryDownloadManifest(context.Context, *pb.RpcGalleryDownloadManifestRequest) *pb.RpcGalleryDownloadManifestResponse
GalleryDownloadIndex(context.Context, *pb.RpcGalleryDownloadIndexRequest) *pb.RpcGalleryDownloadIndexResponse
// General Block commands
// ***
BlockUpload(context.Context, *pb.RpcBlockUploadRequest) *pb.RpcBlockUploadResponse
@ -3230,7 +3242,10 @@ func (*UnimplementedClientCommandsServer) UnsplashSearch(ctx context.Context, re
func (*UnimplementedClientCommandsServer) UnsplashDownload(ctx context.Context, req *pb.RpcUnsplashDownloadRequest) *pb.RpcUnsplashDownloadResponse {
return nil
}
func (*UnimplementedClientCommandsServer) DownloadManifest(ctx context.Context, req *pb.RpcDownloadManifestRequest) *pb.RpcDownloadManifestResponse {
func (*UnimplementedClientCommandsServer) GalleryDownloadManifest(ctx context.Context, req *pb.RpcGalleryDownloadManifestRequest) *pb.RpcGalleryDownloadManifestResponse {
return nil
}
func (*UnimplementedClientCommandsServer) GalleryDownloadIndex(ctx context.Context, req *pb.RpcGalleryDownloadIndexRequest) *pb.RpcGalleryDownloadIndexResponse {
return nil
}
func (*UnimplementedClientCommandsServer) BlockUpload(ctx context.Context, req *pb.RpcBlockUploadRequest) *pb.RpcBlockUploadResponse {
@ -5671,20 +5686,38 @@ func _ClientCommands_UnsplashDownload_Handler(srv interface{}, ctx context.Conte
return interceptor(ctx, in, info, handler)
}
func _ClientCommands_DownloadManifest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(pb.RpcDownloadManifestRequest)
func _ClientCommands_GalleryDownloadManifest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(pb.RpcGalleryDownloadManifestRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ClientCommandsServer).DownloadManifest(ctx, in), nil
return srv.(ClientCommandsServer).GalleryDownloadManifest(ctx, in), nil
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/anytype.ClientCommands/DownloadManifest",
FullMethod: "/anytype.ClientCommands/GalleryDownloadManifest",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ClientCommandsServer).DownloadManifest(ctx, req.(*pb.RpcDownloadManifestRequest)), nil
return srv.(ClientCommandsServer).GalleryDownloadManifest(ctx, req.(*pb.RpcGalleryDownloadManifestRequest)), nil
}
return interceptor(ctx, in, info, handler)
}
func _ClientCommands_GalleryDownloadIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(pb.RpcGalleryDownloadIndexRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ClientCommandsServer).GalleryDownloadIndex(ctx, in), nil
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/anytype.ClientCommands/GalleryDownloadIndex",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ClientCommandsServer).GalleryDownloadIndex(ctx, req.(*pb.RpcGalleryDownloadIndexRequest)), nil
}
return interceptor(ctx, in, info, handler)
}
@ -8024,8 +8057,12 @@ var _ClientCommands_serviceDesc = grpc.ServiceDesc{
Handler: _ClientCommands_UnsplashDownload_Handler,
},
{
MethodName: "DownloadManifest",
Handler: _ClientCommands_DownloadManifest_Handler,
MethodName: "GalleryDownloadManifest",
Handler: _ClientCommands_GalleryDownloadManifest_Handler,
},
{
MethodName: "GalleryDownloadIndex",
Handler: _ClientCommands_GalleryDownloadIndex_Handler,
},
{
MethodName: "BlockUpload",

4
pkg/lib/gateway/gateway.go
View file

@ -261,7 +261,7 @@ func (g *gateway) getFile(ctx context.Context, r *http.Request) (files.File, io.
parts := strings.Split(fileIdAndPath, "/")
fileId := parts[0]
id, err := g.fileObjectService.GetFileIdFromObject(ctx, fileId)
id, err := g.fileObjectService.GetFileIdFromObject(fileId)
if err != nil {
return nil, nil, fmt.Errorf("get file hash from object id: %w", err)
}
@ -322,7 +322,7 @@ func (g *gateway) getImage(ctx context.Context, r *http.Request) (files.File, io
}
} else {
id, err = g.fileObjectService.GetFileIdFromObject(ctx, imageId)
id, err = g.fileObjectService.GetFileIdFromObject(imageId)
if err != nil {
return nil, nil, fmt.Errorf("get file hash from object id: %w", err)
}

13
pkg/lib/localstore/filestore/files.go
View file

@ -113,6 +113,7 @@ type FileStore interface {
SetFileSize(fileId domain.FileId, size int) error
GetFileSize(fileId domain.FileId) (int, error)
GetFileOrigin(fileId domain.FileId) (objectorigin.ObjectOrigin, error)
SetFileOrigin(fileId domain.FileId, origin objectorigin.ObjectOrigin) error
}
func New() FileStore {
@ -550,6 +551,18 @@ func (s *dsFileStore) GetFileOrigin(fileId domain.FileId) (objectorigin.ObjectOr
}, nil
}
func (s *dsFileStore) SetFileOrigin(fileId domain.FileId, origin objectorigin.ObjectOrigin) error {
err := s.setInt(fileOrigin.ChildString(fileId.String()), int(origin.Origin))
if err != nil {
return fmt.Errorf("failed to set file origin: %w", err)
}
err = s.setInt(fileImportType.ChildString(fileId.String()), int(origin.ImportType))
if err != nil {
return fmt.Errorf("failed to set file import type: %w", err)
}
return nil
}
func (s *dsFileStore) Close(ctx context.Context) (err error) {
return nil
}

3
pkg/lib/localstore/objectstore/fixture.go
View file

@ -40,7 +40,8 @@ func NewStoreFixture(t *testing.T) *StoreFixture {
err = fullText.Run(context.Background())
require.NoError(t, err)
db, err := badger.Open(badger.DefaultOptions(filepath.Join(t.TempDir(), "badger")))
badgerDir := filepath.Join(t.TempDir(), "badger")
db, err := badger.Open(badger.DefaultOptions(badgerDir))
require.NoError(t, err)
t.Cleanup(func() {

1597
pkg/lib/pb/model/models.pb.go
View file

File diff suppressed because it is too large Load diff

16
pkg/lib/pb/model/protos/models.proto
View file

@ -1084,4 +1084,20 @@ enum ImageKind {
enum FileIndexingStatus {
NotIndexed = 0;
Indexed = 1;
NotFound = 2;
}
message ManifestInfo {
string schema = 1;
string id = 2;
string name = 3;
string author = 4;
string license = 5;
string title = 6;
string description = 7;
repeated string screenshots = 8;
string downloadLink = 9;
int32 fileSize = 10;
repeated string categories = 11;
string language = 12;
}

47
space/internal/spacecontroller/mock_spacecontroller/mock_SpaceController.go
View file

@ -162,6 +162,53 @@ func (_c *MockSpaceController_Mode_Call) RunAndReturn(run func() mode.Mode) *Moc
return _c
}
// SetStatus provides a mock function with given fields: ctx, status
func (_m *MockSpaceController) SetStatus(ctx context.Context, status spaceinfo.AccountStatus) error {
ret := _m.Called(ctx, status)
if len(ret) == 0 {
panic("no return value specified for SetStatus")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, spaceinfo.AccountStatus) error); ok {
r0 = rf(ctx, status)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockSpaceController_SetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStatus'
type MockSpaceController_SetStatus_Call struct {
*mock.Call
}
// SetStatus is a helper method to define mock.On call
// - ctx context.Context
// - status spaceinfo.AccountStatus
func (_e *MockSpaceController_Expecter) SetStatus(ctx interface{}, status interface{}) *MockSpaceController_SetStatus_Call {
return &MockSpaceController_SetStatus_Call{Call: _e.mock.On("SetStatus", ctx, status)}
}
func (_c *MockSpaceController_SetStatus_Call) Run(run func(ctx context.Context, status spaceinfo.AccountStatus)) *MockSpaceController_SetStatus_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(spaceinfo.AccountStatus))
})
return _c
}
func (_c *MockSpaceController_SetStatus_Call) Return(_a0 error) *MockSpaceController_SetStatus_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockSpaceController_SetStatus_Call) RunAndReturn(run func(context.Context, spaceinfo.AccountStatus) error) *MockSpaceController_SetStatus_Call {
_c.Call.Return(run)
return _c
}
// SpaceId provides a mock function with given fields:
func (_m *MockSpaceController) SpaceId() string {
ret := _m.Called()

48
space/internal/techspace/mock_techspace/mock_TechSpace.go
View file

@ -214,6 +214,54 @@ func (_c *MockTechSpace_Run_Call) RunAndReturn(run func(commonspace.Space, objec
return _c
}
// SetAccessType provides a mock function with given fields: ctx, spaceId, acc
func (_m *MockTechSpace) SetAccessType(ctx context.Context, spaceId string, acc spaceinfo.AccessType) error {
ret := _m.Called(ctx, spaceId, acc)
if len(ret) == 0 {
panic("no return value specified for SetAccessType")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, string, spaceinfo.AccessType) error); ok {
r0 = rf(ctx, spaceId, acc)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockTechSpace_SetAccessType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAccessType'
type MockTechSpace_SetAccessType_Call struct {
*mock.Call
}
// SetAccessType is a helper method to define mock.On call
// - ctx context.Context
// - spaceId string
// - acc spaceinfo.AccessType
func (_e *MockTechSpace_Expecter) SetAccessType(ctx interface{}, spaceId interface{}, acc interface{}) *MockTechSpace_SetAccessType_Call {
return &MockTechSpace_SetAccessType_Call{Call: _e.mock.On("SetAccessType", ctx, spaceId, acc)}
}
func (_c *MockTechSpace_SetAccessType_Call) Run(run func(ctx context.Context, spaceId string, acc spaceinfo.AccessType)) *MockTechSpace_SetAccessType_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(string), args[2].(spaceinfo.AccessType))
})
return _c
}
func (_c *MockTechSpace_SetAccessType_Call) Return(err error) *MockTechSpace_SetAccessType_Call {
_c.Call.Return(err)
return _c
}
func (_c *MockTechSpace_SetAccessType_Call) RunAndReturn(run func(context.Context, string, spaceinfo.AccessType) error) *MockTechSpace_SetAccessType_Call {
_c.Call.Return(run)
return _c
}
// SetLocalInfo provides a mock function with given fields: ctx, info
func (_m *MockTechSpace) SetLocalInfo(ctx context.Context, info spaceinfo.SpaceLocalInfo) error {
ret := _m.Called(ctx, info)

47
space/spacecore/mock_spacecore/mock_SpaceCoreService.go
View file

@ -73,6 +73,53 @@ func (_c *MockSpaceCoreService_Close_Call) RunAndReturn(run func(context.Context
return _c
}
// CloseSpace provides a mock function with given fields: ctx, id
func (_m *MockSpaceCoreService) CloseSpace(ctx context.Context, id string) error {
ret := _m.Called(ctx, id)
if len(ret) == 0 {
panic("no return value specified for CloseSpace")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
r0 = rf(ctx, id)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockSpaceCoreService_CloseSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseSpace'
type MockSpaceCoreService_CloseSpace_Call struct {
*mock.Call
}
// CloseSpace is a helper method to define mock.On call
// - ctx context.Context
// - id string
func (_e *MockSpaceCoreService_Expecter) CloseSpace(ctx interface{}, id interface{}) *MockSpaceCoreService_CloseSpace_Call {
return &MockSpaceCoreService_CloseSpace_Call{Call: _e.mock.On("CloseSpace", ctx, id)}
}
func (_c *MockSpaceCoreService_CloseSpace_Call) Run(run func(ctx context.Context, id string)) *MockSpaceCoreService_CloseSpace_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(string))
})
return _c
}
func (_c *MockSpaceCoreService_CloseSpace_Call) Return(_a0 error) *MockSpaceCoreService_CloseSpace_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockSpaceCoreService_CloseSpace_Call) RunAndReturn(run func(context.Context, string) error) *MockSpaceCoreService_CloseSpace_Call {
_c.Call.Return(run)
return _c
}
// Create provides a mock function with given fields: ctx, replicationKey, metadataPayload
func (_m *MockSpaceCoreService) Create(ctx context.Context, replicationKey uint64, metadataPayload []byte) (*spacecore.AnySpace, error) {
ret := _m.Called(ctx, replicationKey, metadataPayload)

39
tests/blockbuilder/constructors.go
View file

@ -77,10 +77,12 @@ type options struct {
color string
restrictions *model.BlockRestrictions
textStyle model.BlockContentTextStyle
textIconImage string
marks *model.BlockContentTextMarks
fields *types.Struct
id string
backgroundColor string
fileHash string
}
type Option func(*options)
@ -127,6 +129,12 @@ func TextStyle(s model.BlockContentTextStyle) Option {
}
}
func TextIconImage(id string) Option {
return func(o *options) {
o.textIconImage = id
}
}
func TextMarks(m model.BlockContentTextMarks) Option {
return func(o *options) {
o.marks = &m
@ -182,10 +190,11 @@ func Text(s string, opts ...Option) *Block {
return mkBlock(&model.Block{
Content: &model.BlockContentOfText{
Text: &model.BlockContentText{
Text: s,
Style: o.textStyle,
Color: o.color,
Marks: o.marks,
Text: s,
Style: o.textStyle,
Color: o.color,
Marks: o.marks,
IconImage: o.textIconImage,
},
},
}, opts...)
@ -198,3 +207,25 @@ func Row(opts ...Option) *Block {
func Column(opts ...Option) *Block {
return Layout(model.BlockContentLayout_Column, opts...)
}
func FileHash(hash string) Option {
return func(o *options) {
o.fileHash = hash
}
}
func File(targetObjectId string, opts ...Option) *Block {
var o options
for _, apply := range opts {
apply(&o)
}
return mkBlock(&model.Block{
Content: &model.BlockContentOfFile{
File: &model.BlockContentFile{
Hash: o.fileHash,
TargetObjectId: targetObjectId,
},
},
}, opts...)
}

8
util/testMock/file_service_mock.go
View file

@ -48,14 +48,14 @@ func (m *MockFileService) EXPECT() *MockFileServiceMockRecorder {
}
// FileAdd mocks base method.
func (m *MockFileService) FileAdd(arg0 context.Context, arg1 string, arg2 ...files.AddOption) (*files.FileAddResult, error) {
func (m *MockFileService) FileAdd(arg0 context.Context, arg1 string, arg2 ...files.AddOption) (*files.AddResult, error) {
m.ctrl.T.Helper()
varargs := []any{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "FileAdd", varargs...)
ret0, _ := ret[0].(*files.FileAddResult)
ret0, _ := ret[0].(*files.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -143,14 +143,14 @@ func (mr *MockFileServiceMockRecorder) GetSpaceUsage(arg0, arg1 any) *gomock.Cal
}
// ImageAdd mocks base method.
func (m *MockFileService) ImageAdd(arg0 context.Context, arg1 string, arg2 ...files.AddOption) (*files.ImageAddResult, error) {
func (m *MockFileService) ImageAdd(arg0 context.Context, arg1 string, arg2 ...files.AddOption) (*files.AddResult, error) {
m.ctrl.T.Helper()
varargs := []any{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ImageAdd", varargs...)
ret0, _ := ret[0].(*files.ImageAddResult)
ret0, _ := ret[0].(*files.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}