+1234

gen/go/lrc.pb.go

··· 1 1 + // Code generated by protoc-gen-go. DO NOT EDIT. 2 2 + // versions: 3 3 + // protoc-gen-go v1.36.6 4 4 + // protoc v5.29.3 5 5 + // source: lrc.proto 6 6 + 7 7 + package lrcpb 8 8 + 9 9 + import ( 10 10 + protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 11 + protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 12 + reflect "reflect" 13 13 + sync "sync" 14 14 + unsafe "unsafe" 15 15 + ) 16 16 + 17 17 + const ( 18 18 + // Verify that this generated code is sufficiently up-to-date. 19 19 + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 20 20 + // Verify that runtime/protoimpl is sufficiently up-to-date. 21 21 + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 22 22 + ) 23 23 + 24 24 + type Event struct { 25 25 + state protoimpl.MessageState `protogen:"open.v1"` 26 26 + // Types that are valid to be assigned to Msg: 27 27 + // 28 28 + // *Event_Ping 29 29 + // *Event_Pong 30 30 + // *Event_Init 31 31 + // *Event_Pub 32 32 + // *Event_Insert 33 33 + // *Event_Delete 34 34 + // *Event_Mute 35 35 + // *Event_Unmute 36 36 + // *Event_Set 37 37 + // *Event_Get 38 38 + // *Event_Kick 39 39 + // *Event_Hug 40 40 + // *Event_Ban 41 41 + // *Event_Unban 42 42 + Msg isEvent_Msg `protobuf_oneof:"msg"` 43 43 + unknownFields protoimpl.UnknownFields 44 44 + sizeCache protoimpl.SizeCache 45 45 + } 46 46 + 47 47 + func (x *Event) Reset() { 48 48 + *x = Event{} 49 49 + mi := &file_lrc_proto_msgTypes[0] 50 50 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 51 51 + ms.StoreMessageInfo(mi) 52 52 + } 53 53 + 54 54 + func (x *Event) String() string { 55 55 + return protoimpl.X.MessageStringOf(x) 56 56 + } 57 57 + 58 58 + func (*Event) ProtoMessage() {} 59 59 + 60 60 + func (x *Event) ProtoReflect() protoreflect.Message { 61 61 + mi := &file_lrc_proto_msgTypes[0] 62 62 + if x != nil { 63 63 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 64 64 + if ms.LoadMessageInfo() == nil { 65 65 + ms.StoreMessageInfo(mi) 66 66 + } 67 67 + return ms 68 68 + } 69 69 + return mi.MessageOf(x) 70 70 + } 71 71 + 72 72 + // Deprecated: Use Event.ProtoReflect.Descriptor instead. 73 73 + func (*Event) Descriptor() ([]byte, []int) { 74 74 + return file_lrc_proto_rawDescGZIP(), []int{0} 75 75 + } 76 76 + 77 77 + func (x *Event) GetMsg() isEvent_Msg { 78 78 + if x != nil { 79 79 + return x.Msg 80 80 + } 81 81 + return nil 82 82 + } 83 83 + 84 84 + func (x *Event) GetPing() *Ping { 85 85 + if x != nil { 86 86 + if x, ok := x.Msg.(*Event_Ping); ok { 87 87 + return x.Ping 88 88 + } 89 89 + } 90 90 + return nil 91 91 + } 92 92 + 93 93 + func (x *Event) GetPong() *Pong { 94 94 + if x != nil { 95 95 + if x, ok := x.Msg.(*Event_Pong); ok { 96 96 + return x.Pong 97 97 + } 98 98 + } 99 99 + return nil 100 100 + } 101 101 + 102 102 + func (x *Event) GetInit() *Init { 103 103 + if x != nil { 104 104 + if x, ok := x.Msg.(*Event_Init); ok { 105 105 + return x.Init 106 106 + } 107 107 + } 108 108 + return nil 109 109 + } 110 110 + 111 111 + func (x *Event) GetPub() *Pub { 112 112 + if x != nil { 113 113 + if x, ok := x.Msg.(*Event_Pub); ok { 114 114 + return x.Pub 115 115 + } 116 116 + } 117 117 + return nil 118 118 + } 119 119 + 120 120 + func (x *Event) GetInsert() *Insert { 121 121 + if x != nil { 122 122 + if x, ok := x.Msg.(*Event_Insert); ok { 123 123 + return x.Insert 124 124 + } 125 125 + } 126 126 + return nil 127 127 + } 128 128 + 129 129 + func (x *Event) GetDelete() *Delete { 130 130 + if x != nil { 131 131 + if x, ok := x.Msg.(*Event_Delete); ok { 132 132 + return x.Delete 133 133 + } 134 134 + } 135 135 + return nil 136 136 + } 137 137 + 138 138 + func (x *Event) GetMute() *Mute { 139 139 + if x != nil { 140 140 + if x, ok := x.Msg.(*Event_Mute); ok { 141 141 + return x.Mute 142 142 + } 143 143 + } 144 144 + return nil 145 145 + } 146 146 + 147 147 + func (x *Event) GetUnmute() *Unmute { 148 148 + if x != nil { 149 149 + if x, ok := x.Msg.(*Event_Unmute); ok { 150 150 + return x.Unmute 151 151 + } 152 152 + } 153 153 + return nil 154 154 + } 155 155 + 156 156 + func (x *Event) GetSet() *Set { 157 157 + if x != nil { 158 158 + if x, ok := x.Msg.(*Event_Set); ok { 159 159 + return x.Set 160 160 + } 161 161 + } 162 162 + return nil 163 163 + } 164 164 + 165 165 + func (x *Event) GetGet() *Get { 166 166 + if x != nil { 167 167 + if x, ok := x.Msg.(*Event_Get); ok { 168 168 + return x.Get 169 169 + } 170 170 + } 171 171 + return nil 172 172 + } 173 173 + 174 174 + func (x *Event) GetKick() *Kick { 175 175 + if x != nil { 176 176 + if x, ok := x.Msg.(*Event_Kick); ok { 177 177 + return x.Kick 178 178 + } 179 179 + } 180 180 + return nil 181 181 + } 182 182 + 183 183 + func (x *Event) GetHug() *Hug { 184 184 + if x != nil { 185 185 + if x, ok := x.Msg.(*Event_Hug); ok { 186 186 + return x.Hug 187 187 + } 188 188 + } 189 189 + return nil 190 190 + } 191 191 + 192 192 + func (x *Event) GetBan() *Ban { 193 193 + if x != nil { 194 194 + if x, ok := x.Msg.(*Event_Ban); ok { 195 195 + return x.Ban 196 196 + } 197 197 + } 198 198 + return nil 199 199 + } 200 200 + 201 201 + func (x *Event) GetUnban() *Unban { 202 202 + if x != nil { 203 203 + if x, ok := x.Msg.(*Event_Unban); ok { 204 204 + return x.Unban 205 205 + } 206 206 + } 207 207 + return nil 208 208 + } 209 209 + 210 210 + type isEvent_Msg interface { 211 211 + isEvent_Msg() 212 212 + } 213 213 + 214 214 + type Event_Ping struct { 215 215 + Ping *Ping `protobuf:"bytes,1,opt,name=ping,proto3,oneof"` 216 216 + } 217 217 + 218 218 + type Event_Pong struct { 219 219 + Pong *Pong `protobuf:"bytes,2,opt,name=pong,proto3,oneof"` 220 220 + } 221 221 + 222 222 + type Event_Init struct { 223 223 + Init *Init `protobuf:"bytes,3,opt,name=init,proto3,oneof"` 224 224 + } 225 225 + 226 226 + type Event_Pub struct { 227 227 + Pub *Pub `protobuf:"bytes,4,opt,name=pub,proto3,oneof"` 228 228 + } 229 229 + 230 230 + type Event_Insert struct { 231 231 + Insert *Insert `protobuf:"bytes,5,opt,name=insert,proto3,oneof"` 232 232 + } 233 233 + 234 234 + type Event_Delete struct { 235 235 + Delete *Delete `protobuf:"bytes,6,opt,name=delete,proto3,oneof"` 236 236 + } 237 237 + 238 238 + type Event_Mute struct { 239 239 + Mute *Mute `protobuf:"bytes,7,opt,name=mute,proto3,oneof"` 240 240 + } 241 241 + 242 242 + type Event_Unmute struct { 243 243 + Unmute *Unmute `protobuf:"bytes,8,opt,name=unmute,proto3,oneof"` 244 244 + } 245 245 + 246 246 + type Event_Set struct { 247 247 + Set *Set `protobuf:"bytes,9,opt,name=set,proto3,oneof"` 248 248 + } 249 249 + 250 250 + type Event_Get struct { 251 251 + Get *Get `protobuf:"bytes,10,opt,name=get,proto3,oneof"` 252 252 + } 253 253 + 254 254 + type Event_Kick struct { 255 255 + Kick *Kick `protobuf:"bytes,11,opt,name=kick,proto3,oneof"` 256 256 + } 257 257 + 258 258 + type Event_Hug struct { 259 259 + Hug *Hug `protobuf:"bytes,12,opt,name=hug,proto3,oneof"` 260 260 + } 261 261 + 262 262 + type Event_Ban struct { 263 263 + Ban *Ban `protobuf:"bytes,13,opt,name=ban,proto3,oneof"` 264 264 + } 265 265 + 266 266 + type Event_Unban struct { 267 267 + Unban *Unban `protobuf:"bytes,14,opt,name=unban,proto3,oneof"` 268 268 + } 269 269 + 270 270 + func (*Event_Ping) isEvent_Msg() {} 271 271 + 272 272 + func (*Event_Pong) isEvent_Msg() {} 273 273 + 274 274 + func (*Event_Init) isEvent_Msg() {} 275 275 + 276 276 + func (*Event_Pub) isEvent_Msg() {} 277 277 + 278 278 + func (*Event_Insert) isEvent_Msg() {} 279 279 + 280 280 + func (*Event_Delete) isEvent_Msg() {} 281 281 + 282 282 + func (*Event_Mute) isEvent_Msg() {} 283 283 + 284 284 + func (*Event_Unmute) isEvent_Msg() {} 285 285 + 286 286 + func (*Event_Set) isEvent_Msg() {} 287 287 + 288 288 + func (*Event_Get) isEvent_Msg() {} 289 289 + 290 290 + func (*Event_Kick) isEvent_Msg() {} 291 291 + 292 292 + func (*Event_Hug) isEvent_Msg() {} 293 293 + 294 294 + func (*Event_Ban) isEvent_Msg() {} 295 295 + 296 296 + func (*Event_Unban) isEvent_Msg() {} 297 297 + 298 298 + type Ping struct { 299 299 + state protoimpl.MessageState `protogen:"open.v1"` 300 300 + unknownFields protoimpl.UnknownFields 301 301 + sizeCache protoimpl.SizeCache 302 302 + } 303 303 + 304 304 + func (x *Ping) Reset() { 305 305 + *x = Ping{} 306 306 + mi := &file_lrc_proto_msgTypes[1] 307 307 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 308 308 + ms.StoreMessageInfo(mi) 309 309 + } 310 310 + 311 311 + func (x *Ping) String() string { 312 312 + return protoimpl.X.MessageStringOf(x) 313 313 + } 314 314 + 315 315 + func (*Ping) ProtoMessage() {} 316 316 + 317 317 + func (x *Ping) ProtoReflect() protoreflect.Message { 318 318 + mi := &file_lrc_proto_msgTypes[1] 319 319 + if x != nil { 320 320 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 321 321 + if ms.LoadMessageInfo() == nil { 322 322 + ms.StoreMessageInfo(mi) 323 323 + } 324 324 + return ms 325 325 + } 326 326 + return mi.MessageOf(x) 327 327 + } 328 328 + 329 329 + // Deprecated: Use Ping.ProtoReflect.Descriptor instead. 330 330 + func (*Ping) Descriptor() ([]byte, []int) { 331 331 + return file_lrc_proto_rawDescGZIP(), []int{1} 332 332 + } 333 333 + 334 334 + type Pong struct { 335 335 + state protoimpl.MessageState `protogen:"open.v1"` 336 336 + unknownFields protoimpl.UnknownFields 337 337 + sizeCache protoimpl.SizeCache 338 338 + } 339 339 + 340 340 + func (x *Pong) Reset() { 341 341 + *x = Pong{} 342 342 + mi := &file_lrc_proto_msgTypes[2] 343 343 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 344 344 + ms.StoreMessageInfo(mi) 345 345 + } 346 346 + 347 347 + func (x *Pong) String() string { 348 348 + return protoimpl.X.MessageStringOf(x) 349 349 + } 350 350 + 351 351 + func (*Pong) ProtoMessage() {} 352 352 + 353 353 + func (x *Pong) ProtoReflect() protoreflect.Message { 354 354 + mi := &file_lrc_proto_msgTypes[2] 355 355 + if x != nil { 356 356 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 357 357 + if ms.LoadMessageInfo() == nil { 358 358 + ms.StoreMessageInfo(mi) 359 359 + } 360 360 + return ms 361 361 + } 362 362 + return mi.MessageOf(x) 363 363 + } 364 364 + 365 365 + // Deprecated: Use Pong.ProtoReflect.Descriptor instead. 366 366 + func (*Pong) Descriptor() ([]byte, []int) { 367 367 + return file_lrc_proto_rawDescGZIP(), []int{2} 368 368 + } 369 369 + 370 370 + type Init struct { 371 371 + state protoimpl.MessageState `protogen:"open.v1"` 372 372 + Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` 373 373 + Nick string `protobuf:"bytes,2,opt,name=nick,proto3" json:"nick,omitempty"` 374 374 + ExternalID string `protobuf:"bytes,3,opt,name=externalID,proto3" json:"externalID,omitempty"` 375 375 + Color uint32 `protobuf:"varint,4,opt,name=color,proto3" json:"color,omitempty"` 376 376 + Echoed bool `protobuf:"varint,5,opt,name=echoed,proto3" json:"echoed,omitempty"` 377 377 + unknownFields protoimpl.UnknownFields 378 378 + sizeCache protoimpl.SizeCache 379 379 + } 380 380 + 381 381 + func (x *Init) Reset() { 382 382 + *x = Init{} 383 383 + mi := &file_lrc_proto_msgTypes[3] 384 384 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 385 385 + ms.StoreMessageInfo(mi) 386 386 + } 387 387 + 388 388 + func (x *Init) String() string { 389 389 + return protoimpl.X.MessageStringOf(x) 390 390 + } 391 391 + 392 392 + func (*Init) ProtoMessage() {} 393 393 + 394 394 + func (x *Init) ProtoReflect() protoreflect.Message { 395 395 + mi := &file_lrc_proto_msgTypes[3] 396 396 + if x != nil { 397 397 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 398 398 + if ms.LoadMessageInfo() == nil { 399 399 + ms.StoreMessageInfo(mi) 400 400 + } 401 401 + return ms 402 402 + } 403 403 + return mi.MessageOf(x) 404 404 + } 405 405 + 406 406 + // Deprecated: Use Init.ProtoReflect.Descriptor instead. 407 407 + func (*Init) Descriptor() ([]byte, []int) { 408 408 + return file_lrc_proto_rawDescGZIP(), []int{3} 409 409 + } 410 410 + 411 411 + func (x *Init) GetId() uint32 { 412 412 + if x != nil { 413 413 + return x.Id 414 414 + } 415 415 + return 0 416 416 + } 417 417 + 418 418 + func (x *Init) GetNick() string { 419 419 + if x != nil { 420 420 + return x.Nick 421 421 + } 422 422 + return "" 423 423 + } 424 424 + 425 425 + func (x *Init) GetExternalID() string { 426 426 + if x != nil { 427 427 + return x.ExternalID 428 428 + } 429 429 + return "" 430 430 + } 431 431 + 432 432 + func (x *Init) GetColor() uint32 { 433 433 + if x != nil { 434 434 + return x.Color 435 435 + } 436 436 + return 0 437 437 + } 438 438 + 439 439 + func (x *Init) GetEchoed() bool { 440 440 + if x != nil { 441 441 + return x.Echoed 442 442 + } 443 443 + return false 444 444 + } 445 445 + 446 446 + type Pub struct { 447 447 + state protoimpl.MessageState `protogen:"open.v1"` 448 448 + Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` 449 449 + unknownFields protoimpl.UnknownFields 450 450 + sizeCache protoimpl.SizeCache 451 451 + } 452 452 + 453 453 + func (x *Pub) Reset() { 454 454 + *x = Pub{} 455 455 + mi := &file_lrc_proto_msgTypes[4] 456 456 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 457 457 + ms.StoreMessageInfo(mi) 458 458 + } 459 459 + 460 460 + func (x *Pub) String() string { 461 461 + return protoimpl.X.MessageStringOf(x) 462 462 + } 463 463 + 464 464 + func (*Pub) ProtoMessage() {} 465 465 + 466 466 + func (x *Pub) ProtoReflect() protoreflect.Message { 467 467 + mi := &file_lrc_proto_msgTypes[4] 468 468 + if x != nil { 469 469 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 470 470 + if ms.LoadMessageInfo() == nil { 471 471 + ms.StoreMessageInfo(mi) 472 472 + } 473 473 + return ms 474 474 + } 475 475 + return mi.MessageOf(x) 476 476 + } 477 477 + 478 478 + // Deprecated: Use Pub.ProtoReflect.Descriptor instead. 479 479 + func (*Pub) Descriptor() ([]byte, []int) { 480 480 + return file_lrc_proto_rawDescGZIP(), []int{4} 481 481 + } 482 482 + 483 483 + func (x *Pub) GetId() uint32 { 484 484 + if x != nil { 485 485 + return x.Id 486 486 + } 487 487 + return 0 488 488 + } 489 489 + 490 490 + type Insert struct { 491 491 + state protoimpl.MessageState `protogen:"open.v1"` 492 492 + Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` 493 493 + Body string `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` 494 494 + ByteIndex uint32 `protobuf:"varint,3,opt,name=byteIndex,proto3" json:"byteIndex,omitempty"` 495 495 + unknownFields protoimpl.UnknownFields 496 496 + sizeCache protoimpl.SizeCache 497 497 + } 498 498 + 499 499 + func (x *Insert) Reset() { 500 500 + *x = Insert{} 501 501 + mi := &file_lrc_proto_msgTypes[5] 502 502 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 503 503 + ms.StoreMessageInfo(mi) 504 504 + } 505 505 + 506 506 + func (x *Insert) String() string { 507 507 + return protoimpl.X.MessageStringOf(x) 508 508 + } 509 509 + 510 510 + func (*Insert) ProtoMessage() {} 511 511 + 512 512 + func (x *Insert) ProtoReflect() protoreflect.Message { 513 513 + mi := &file_lrc_proto_msgTypes[5] 514 514 + if x != nil { 515 515 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 516 516 + if ms.LoadMessageInfo() == nil { 517 517 + ms.StoreMessageInfo(mi) 518 518 + } 519 519 + return ms 520 520 + } 521 521 + return mi.MessageOf(x) 522 522 + } 523 523 + 524 524 + // Deprecated: Use Insert.ProtoReflect.Descriptor instead. 525 525 + func (*Insert) Descriptor() ([]byte, []int) { 526 526 + return file_lrc_proto_rawDescGZIP(), []int{5} 527 527 + } 528 528 + 529 529 + func (x *Insert) GetId() uint32 { 530 530 + if x != nil { 531 531 + return x.Id 532 532 + } 533 533 + return 0 534 534 + } 535 535 + 536 536 + func (x *Insert) GetBody() string { 537 537 + if x != nil { 538 538 + return x.Body 539 539 + } 540 540 + return "" 541 541 + } 542 542 + 543 543 + func (x *Insert) GetByteIndex() uint32 { 544 544 + if x != nil { 545 545 + return x.ByteIndex 546 546 + } 547 547 + return 0 548 548 + } 549 549 + 550 550 + type Delete struct { 551 551 + state protoimpl.MessageState `protogen:"open.v1"` 552 552 + Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` 553 553 + ByteStart uint32 `protobuf:"varint,2,opt,name=byteStart,proto3" json:"byteStart,omitempty"` 554 554 + ByteEnd uint32 `protobuf:"varint,3,opt,name=byteEnd,proto3" json:"byteEnd,omitempty"` 555 555 + unknownFields protoimpl.UnknownFields 556 556 + sizeCache protoimpl.SizeCache 557 557 + } 558 558 + 559 559 + func (x *Delete) Reset() { 560 560 + *x = Delete{} 561 561 + mi := &file_lrc_proto_msgTypes[6] 562 562 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 563 563 + ms.StoreMessageInfo(mi) 564 564 + } 565 565 + 566 566 + func (x *Delete) String() string { 567 567 + return protoimpl.X.MessageStringOf(x) 568 568 + } 569 569 + 570 570 + func (*Delete) ProtoMessage() {} 571 571 + 572 572 + func (x *Delete) ProtoReflect() protoreflect.Message { 573 573 + mi := &file_lrc_proto_msgTypes[6] 574 574 + if x != nil { 575 575 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 576 576 + if ms.LoadMessageInfo() == nil { 577 577 + ms.StoreMessageInfo(mi) 578 578 + } 579 579 + return ms 580 580 + } 581 581 + return mi.MessageOf(x) 582 582 + } 583 583 + 584 584 + // Deprecated: Use Delete.ProtoReflect.Descriptor instead. 585 585 + func (*Delete) Descriptor() ([]byte, []int) { 586 586 + return file_lrc_proto_rawDescGZIP(), []int{6} 587 587 + } 588 588 + 589 589 + func (x *Delete) GetId() uint32 { 590 590 + if x != nil { 591 591 + return x.Id 592 592 + } 593 593 + return 0 594 594 + } 595 595 + 596 596 + func (x *Delete) GetByteStart() uint32 { 597 597 + if x != nil { 598 598 + return x.ByteStart 599 599 + } 600 600 + return 0 601 601 + } 602 602 + 603 603 + func (x *Delete) GetByteEnd() uint32 { 604 604 + if x != nil { 605 605 + return x.ByteEnd 606 606 + } 607 607 + return 0 608 608 + } 609 609 + 610 610 + type Mute struct { 611 611 + state protoimpl.MessageState `protogen:"open.v1"` 612 612 + Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` 613 613 + unknownFields protoimpl.UnknownFields 614 614 + sizeCache protoimpl.SizeCache 615 615 + } 616 616 + 617 617 + func (x *Mute) Reset() { 618 618 + *x = Mute{} 619 619 + mi := &file_lrc_proto_msgTypes[7] 620 620 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 621 621 + ms.StoreMessageInfo(mi) 622 622 + } 623 623 + 624 624 + func (x *Mute) String() string { 625 625 + return protoimpl.X.MessageStringOf(x) 626 626 + } 627 627 + 628 628 + func (*Mute) ProtoMessage() {} 629 629 + 630 630 + func (x *Mute) ProtoReflect() protoreflect.Message { 631 631 + mi := &file_lrc_proto_msgTypes[7] 632 632 + if x != nil { 633 633 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 634 634 + if ms.LoadMessageInfo() == nil { 635 635 + ms.StoreMessageInfo(mi) 636 636 + } 637 637 + return ms 638 638 + } 639 639 + return mi.MessageOf(x) 640 640 + } 641 641 + 642 642 + // Deprecated: Use Mute.ProtoReflect.Descriptor instead. 643 643 + func (*Mute) Descriptor() ([]byte, []int) { 644 644 + return file_lrc_proto_rawDescGZIP(), []int{7} 645 645 + } 646 646 + 647 647 + func (x *Mute) GetId() uint32 { 648 648 + if x != nil { 649 649 + return x.Id 650 650 + } 651 651 + return 0 652 652 + } 653 653 + 654 654 + type Unmute struct { 655 655 + state protoimpl.MessageState `protogen:"open.v1"` 656 656 + Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` 657 657 + unknownFields protoimpl.UnknownFields 658 658 + sizeCache protoimpl.SizeCache 659 659 + } 660 660 + 661 661 + func (x *Unmute) Reset() { 662 662 + *x = Unmute{} 663 663 + mi := &file_lrc_proto_msgTypes[8] 664 664 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 665 665 + ms.StoreMessageInfo(mi) 666 666 + } 667 667 + 668 668 + func (x *Unmute) String() string { 669 669 + return protoimpl.X.MessageStringOf(x) 670 670 + } 671 671 + 672 672 + func (*Unmute) ProtoMessage() {} 673 673 + 674 674 + func (x *Unmute) ProtoReflect() protoreflect.Message { 675 675 + mi := &file_lrc_proto_msgTypes[8] 676 676 + if x != nil { 677 677 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 678 678 + if ms.LoadMessageInfo() == nil { 679 679 + ms.StoreMessageInfo(mi) 680 680 + } 681 681 + return ms 682 682 + } 683 683 + return mi.MessageOf(x) 684 684 + } 685 685 + 686 686 + // Deprecated: Use Unmute.ProtoReflect.Descriptor instead. 687 687 + func (*Unmute) Descriptor() ([]byte, []int) { 688 688 + return file_lrc_proto_rawDescGZIP(), []int{8} 689 689 + } 690 690 + 691 691 + func (x *Unmute) GetId() uint32 { 692 692 + if x != nil { 693 693 + return x.Id 694 694 + } 695 695 + return 0 696 696 + } 697 697 + 698 698 + type Set struct { 699 699 + state protoimpl.MessageState `protogen:"open.v1"` 700 700 + Nick string `protobuf:"bytes,1,opt,name=nick,proto3" json:"nick,omitempty"` 701 701 + ExternalID string `protobuf:"bytes,2,opt,name=externalID,proto3" json:"externalID,omitempty"` 702 702 + Color uint32 `protobuf:"varint,3,opt,name=color,proto3" json:"color,omitempty"` 703 703 + unknownFields protoimpl.UnknownFields 704 704 + sizeCache protoimpl.SizeCache 705 705 + } 706 706 + 707 707 + func (x *Set) Reset() { 708 708 + *x = Set{} 709 709 + mi := &file_lrc_proto_msgTypes[9] 710 710 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 711 711 + ms.StoreMessageInfo(mi) 712 712 + } 713 713 + 714 714 + func (x *Set) String() string { 715 715 + return protoimpl.X.MessageStringOf(x) 716 716 + } 717 717 + 718 718 + func (*Set) ProtoMessage() {} 719 719 + 720 720 + func (x *Set) ProtoReflect() protoreflect.Message { 721 721 + mi := &file_lrc_proto_msgTypes[9] 722 722 + if x != nil { 723 723 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 724 724 + if ms.LoadMessageInfo() == nil { 725 725 + ms.StoreMessageInfo(mi) 726 726 + } 727 727 + return ms 728 728 + } 729 729 + return mi.MessageOf(x) 730 730 + } 731 731 + 732 732 + // Deprecated: Use Set.ProtoReflect.Descriptor instead. 733 733 + func (*Set) Descriptor() ([]byte, []int) { 734 734 + return file_lrc_proto_rawDescGZIP(), []int{9} 735 735 + } 736 736 + 737 737 + func (x *Set) GetNick() string { 738 738 + if x != nil { 739 739 + return x.Nick 740 740 + } 741 741 + return "" 742 742 + } 743 743 + 744 744 + func (x *Set) GetExternalID() string { 745 745 + if x != nil { 746 746 + return x.ExternalID 747 747 + } 748 748 + return "" 749 749 + } 750 750 + 751 751 + func (x *Set) GetColor() uint32 { 752 752 + if x != nil { 753 753 + return x.Color 754 754 + } 755 755 + return 0 756 756 + } 757 757 + 758 758 + type Get struct { 759 759 + state protoimpl.MessageState `protogen:"open.v1"` 760 760 + Topic string `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"` 761 761 + Connected uint32 `protobuf:"varint,2,opt,name=connected,proto3" json:"connected,omitempty"` 762 762 + unknownFields protoimpl.UnknownFields 763 763 + sizeCache protoimpl.SizeCache 764 764 + } 765 765 + 766 766 + func (x *Get) Reset() { 767 767 + *x = Get{} 768 768 + mi := &file_lrc_proto_msgTypes[10] 769 769 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 770 770 + ms.StoreMessageInfo(mi) 771 771 + } 772 772 + 773 773 + func (x *Get) String() string { 774 774 + return protoimpl.X.MessageStringOf(x) 775 775 + } 776 776 + 777 777 + func (*Get) ProtoMessage() {} 778 778 + 779 779 + func (x *Get) ProtoReflect() protoreflect.Message { 780 780 + mi := &file_lrc_proto_msgTypes[10] 781 781 + if x != nil { 782 782 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 783 783 + if ms.LoadMessageInfo() == nil { 784 784 + ms.StoreMessageInfo(mi) 785 785 + } 786 786 + return ms 787 787 + } 788 788 + return mi.MessageOf(x) 789 789 + } 790 790 + 791 791 + // Deprecated: Use Get.ProtoReflect.Descriptor instead. 792 792 + func (*Get) Descriptor() ([]byte, []int) { 793 793 + return file_lrc_proto_rawDescGZIP(), []int{10} 794 794 + } 795 795 + 796 796 + func (x *Get) GetTopic() string { 797 797 + if x != nil { 798 798 + return x.Topic 799 799 + } 800 800 + return "" 801 801 + } 802 802 + 803 803 + func (x *Get) GetConnected() uint32 { 804 804 + if x != nil { 805 805 + return x.Connected 806 806 + } 807 807 + return 0 808 808 + } 809 809 + 810 810 + type Sudo struct { 811 811 + state protoimpl.MessageState `protogen:"open.v1"` 812 812 + ExternalID string `protobuf:"bytes,1,opt,name=externalID,proto3" json:"externalID,omitempty"` 813 813 + Secret string `protobuf:"bytes,2,opt,name=secret,proto3" json:"secret,omitempty"` 814 814 + unknownFields protoimpl.UnknownFields 815 815 + sizeCache protoimpl.SizeCache 816 816 + } 817 817 + 818 818 + func (x *Sudo) Reset() { 819 819 + *x = Sudo{} 820 820 + mi := &file_lrc_proto_msgTypes[11] 821 821 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 822 822 + ms.StoreMessageInfo(mi) 823 823 + } 824 824 + 825 825 + func (x *Sudo) String() string { 826 826 + return protoimpl.X.MessageStringOf(x) 827 827 + } 828 828 + 829 829 + func (*Sudo) ProtoMessage() {} 830 830 + 831 831 + func (x *Sudo) ProtoReflect() protoreflect.Message { 832 832 + mi := &file_lrc_proto_msgTypes[11] 833 833 + if x != nil { 834 834 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 835 835 + if ms.LoadMessageInfo() == nil { 836 836 + ms.StoreMessageInfo(mi) 837 837 + } 838 838 + return ms 839 839 + } 840 840 + return mi.MessageOf(x) 841 841 + } 842 842 + 843 843 + // Deprecated: Use Sudo.ProtoReflect.Descriptor instead. 844 844 + func (*Sudo) Descriptor() ([]byte, []int) { 845 845 + return file_lrc_proto_rawDescGZIP(), []int{11} 846 846 + } 847 847 + 848 848 + func (x *Sudo) GetExternalID() string { 849 849 + if x != nil { 850 850 + return x.ExternalID 851 851 + } 852 852 + return "" 853 853 + } 854 854 + 855 855 + func (x *Sudo) GetSecret() string { 856 856 + if x != nil { 857 857 + return x.Secret 858 858 + } 859 859 + return "" 860 860 + } 861 861 + 862 862 + type Kick struct { 863 863 + state protoimpl.MessageState `protogen:"open.v1"` 864 864 + Privileges *Sudo `protobuf:"bytes,1,opt,name=privileges,proto3" json:"privileges,omitempty"` 865 865 + Id uint32 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` 866 866 + unknownFields protoimpl.UnknownFields 867 867 + sizeCache protoimpl.SizeCache 868 868 + } 869 869 + 870 870 + func (x *Kick) Reset() { 871 871 + *x = Kick{} 872 872 + mi := &file_lrc_proto_msgTypes[12] 873 873 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 874 874 + ms.StoreMessageInfo(mi) 875 875 + } 876 876 + 877 877 + func (x *Kick) String() string { 878 878 + return protoimpl.X.MessageStringOf(x) 879 879 + } 880 880 + 881 881 + func (*Kick) ProtoMessage() {} 882 882 + 883 883 + func (x *Kick) ProtoReflect() protoreflect.Message { 884 884 + mi := &file_lrc_proto_msgTypes[12] 885 885 + if x != nil { 886 886 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 887 887 + if ms.LoadMessageInfo() == nil { 888 888 + ms.StoreMessageInfo(mi) 889 889 + } 890 890 + return ms 891 891 + } 892 892 + return mi.MessageOf(x) 893 893 + } 894 894 + 895 895 + // Deprecated: Use Kick.ProtoReflect.Descriptor instead. 896 896 + func (*Kick) Descriptor() ([]byte, []int) { 897 897 + return file_lrc_proto_rawDescGZIP(), []int{12} 898 898 + } 899 899 + 900 900 + func (x *Kick) GetPrivileges() *Sudo { 901 901 + if x != nil { 902 902 + return x.Privileges 903 903 + } 904 904 + return nil 905 905 + } 906 906 + 907 907 + func (x *Kick) GetId() uint32 { 908 908 + if x != nil { 909 909 + return x.Id 910 910 + } 911 911 + return 0 912 912 + } 913 913 + 914 914 + type Hug struct { 915 915 + state protoimpl.MessageState `protogen:"open.v1"` 916 916 + Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` 917 917 + unknownFields protoimpl.UnknownFields 918 918 + sizeCache protoimpl.SizeCache 919 919 + } 920 920 + 921 921 + func (x *Hug) Reset() { 922 922 + *x = Hug{} 923 923 + mi := &file_lrc_proto_msgTypes[13] 924 924 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 925 925 + ms.StoreMessageInfo(mi) 926 926 + } 927 927 + 928 928 + func (x *Hug) String() string { 929 929 + return protoimpl.X.MessageStringOf(x) 930 930 + } 931 931 + 932 932 + func (*Hug) ProtoMessage() {} 933 933 + 934 934 + func (x *Hug) ProtoReflect() protoreflect.Message { 935 935 + mi := &file_lrc_proto_msgTypes[13] 936 936 + if x != nil { 937 937 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 938 938 + if ms.LoadMessageInfo() == nil { 939 939 + ms.StoreMessageInfo(mi) 940 940 + } 941 941 + return ms 942 942 + } 943 943 + return mi.MessageOf(x) 944 944 + } 945 945 + 946 946 + // Deprecated: Use Hug.ProtoReflect.Descriptor instead. 947 947 + func (*Hug) Descriptor() ([]byte, []int) { 948 948 + return file_lrc_proto_rawDescGZIP(), []int{13} 949 949 + } 950 950 + 951 951 + func (x *Hug) GetId() uint32 { 952 952 + if x != nil { 953 953 + return x.Id 954 954 + } 955 955 + return 0 956 956 + } 957 957 + 958 958 + type Ban struct { 959 959 + state protoimpl.MessageState `protogen:"open.v1"` 960 960 + Privileges *Sudo `protobuf:"bytes,1,opt,name=privileges,proto3" json:"privileges,omitempty"` 961 961 + Id uint32 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` 962 962 + unknownFields protoimpl.UnknownFields 963 963 + sizeCache protoimpl.SizeCache 964 964 + } 965 965 + 966 966 + func (x *Ban) Reset() { 967 967 + *x = Ban{} 968 968 + mi := &file_lrc_proto_msgTypes[14] 969 969 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 970 970 + ms.StoreMessageInfo(mi) 971 971 + } 972 972 + 973 973 + func (x *Ban) String() string { 974 974 + return protoimpl.X.MessageStringOf(x) 975 975 + } 976 976 + 977 977 + func (*Ban) ProtoMessage() {} 978 978 + 979 979 + func (x *Ban) ProtoReflect() protoreflect.Message { 980 980 + mi := &file_lrc_proto_msgTypes[14] 981 981 + if x != nil { 982 982 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 983 983 + if ms.LoadMessageInfo() == nil { 984 984 + ms.StoreMessageInfo(mi) 985 985 + } 986 986 + return ms 987 987 + } 988 988 + return mi.MessageOf(x) 989 989 + } 990 990 + 991 991 + // Deprecated: Use Ban.ProtoReflect.Descriptor instead. 992 992 + func (*Ban) Descriptor() ([]byte, []int) { 993 993 + return file_lrc_proto_rawDescGZIP(), []int{14} 994 994 + } 995 995 + 996 996 + func (x *Ban) GetPrivileges() *Sudo { 997 997 + if x != nil { 998 998 + return x.Privileges 999 999 + } 1000 1000 + return nil 1001 1001 + } 1002 1002 + 1003 1003 + func (x *Ban) GetId() uint32 { 1004 1004 + if x != nil { 1005 1005 + return x.Id 1006 1006 + } 1007 1007 + return 0 1008 1008 + } 1009 1009 + 1010 1010 + type Unban struct { 1011 1011 + state protoimpl.MessageState `protogen:"open.v1"` 1012 1012 + Privileges *Sudo `protobuf:"bytes,1,opt,name=privileges,proto3" json:"privileges,omitempty"` 1013 1013 + Id uint32 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` 1014 1014 + unknownFields protoimpl.UnknownFields 1015 1015 + sizeCache protoimpl.SizeCache 1016 1016 + } 1017 1017 + 1018 1018 + func (x *Unban) Reset() { 1019 1019 + *x = Unban{} 1020 1020 + mi := &file_lrc_proto_msgTypes[15] 1021 1021 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1022 1022 + ms.StoreMessageInfo(mi) 1023 1023 + } 1024 1024 + 1025 1025 + func (x *Unban) String() string { 1026 1026 + return protoimpl.X.MessageStringOf(x) 1027 1027 + } 1028 1028 + 1029 1029 + func (*Unban) ProtoMessage() {} 1030 1030 + 1031 1031 + func (x *Unban) ProtoReflect() protoreflect.Message { 1032 1032 + mi := &file_lrc_proto_msgTypes[15] 1033 1033 + if x != nil { 1034 1034 + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1035 1035 + if ms.LoadMessageInfo() == nil { 1036 1036 + ms.StoreMessageInfo(mi) 1037 1037 + } 1038 1038 + return ms 1039 1039 + } 1040 1040 + return mi.MessageOf(x) 1041 1041 + } 1042 1042 + 1043 1043 + // Deprecated: Use Unban.ProtoReflect.Descriptor instead. 1044 1044 + func (*Unban) Descriptor() ([]byte, []int) { 1045 1045 + return file_lrc_proto_rawDescGZIP(), []int{15} 1046 1046 + } 1047 1047 + 1048 1048 + func (x *Unban) GetPrivileges() *Sudo { 1049 1049 + if x != nil { 1050 1050 + return x.Privileges 1051 1051 + } 1052 1052 + return nil 1053 1053 + } 1054 1054 + 1055 1055 + func (x *Unban) GetId() uint32 { 1056 1056 + if x != nil { 1057 1057 + return x.Id 1058 1058 + } 1059 1059 + return 0 1060 1060 + } 1061 1061 + 1062 1062 + var File_lrc_proto protoreflect.FileDescriptor 1063 1063 + 1064 1064 + const file_lrc_proto_rawDesc = "" + 1065 1065 + "\n" + 1066 1066 + "\tlrc.proto\"\xaa\x03\n" + 1067 1067 + "\x05Event\x12\x1b\n" + 1068 1068 + "\x04ping\x18\x01 \x01(\v2\x05.PingH\x00R\x04ping\x12\x1b\n" + 1069 1069 + "\x04pong\x18\x02 \x01(\v2\x05.PongH\x00R\x04pong\x12\x1b\n" + 1070 1070 + "\x04init\x18\x03 \x01(\v2\x05.InitH\x00R\x04init\x12\x18\n" + 1071 1071 + "\x03pub\x18\x04 \x01(\v2\x04.PubH\x00R\x03pub\x12!\n" + 1072 1072 + "\x06insert\x18\x05 \x01(\v2\a.InsertH\x00R\x06insert\x12!\n" + 1073 1073 + "\x06delete\x18\x06 \x01(\v2\a.DeleteH\x00R\x06delete\x12\x1b\n" + 1074 1074 + "\x04mute\x18\a \x01(\v2\x05.MuteH\x00R\x04mute\x12!\n" + 1075 1075 + "\x06unmute\x18\b \x01(\v2\a.UnmuteH\x00R\x06unmute\x12\x18\n" + 1076 1076 + "\x03set\x18\t \x01(\v2\x04.SetH\x00R\x03set\x12\x18\n" + 1077 1077 + "\x03get\x18\n" + 1078 1078 + " \x01(\v2\x04.GetH\x00R\x03get\x12\x1b\n" + 1079 1079 + "\x04kick\x18\v \x01(\v2\x05.KickH\x00R\x04kick\x12\x18\n" + 1080 1080 + "\x03hug\x18\f \x01(\v2\x04.HugH\x00R\x03hug\x12\x18\n" + 1081 1081 + "\x03ban\x18\r \x01(\v2\x04.BanH\x00R\x03ban\x12\x1e\n" + 1082 1082 + "\x05unban\x18\x0e \x01(\v2\x06.UnbanH\x00R\x05unbanB\x05\n" + 1083 1083 + "\x03msg\"\x06\n" + 1084 1084 + "\x04Ping\"\x06\n" + 1085 1085 + "\x04Pong\"x\n" + 1086 1086 + "\x04Init\x12\x0e\n" + 1087 1087 + "\x02id\x18\x01 \x01(\rR\x02id\x12\x12\n" + 1088 1088 + "\x04nick\x18\x02 \x01(\tR\x04nick\x12\x1e\n" + 1089 1089 + "\n" + 1090 1090 + "externalID\x18\x03 \x01(\tR\n" + 1091 1091 + "externalID\x12\x14\n" + 1092 1092 + "\x05color\x18\x04 \x01(\rR\x05color\x12\x16\n" + 1093 1093 + "\x06echoed\x18\x05 \x01(\bR\x06echoed\"\x15\n" + 1094 1094 + "\x03Pub\x12\x0e\n" + 1095 1095 + "\x02id\x18\x01 \x01(\rR\x02id\"J\n" + 1096 1096 + "\x06Insert\x12\x0e\n" + 1097 1097 + "\x02id\x18\x01 \x01(\rR\x02id\x12\x12\n" + 1098 1098 + "\x04body\x18\x02 \x01(\tR\x04body\x12\x1c\n" + 1099 1099 + "\tbyteIndex\x18\x03 \x01(\rR\tbyteIndex\"P\n" + 1100 1100 + "\x06Delete\x12\x0e\n" + 1101 1101 + "\x02id\x18\x01 \x01(\rR\x02id\x12\x1c\n" + 1102 1102 + "\tbyteStart\x18\x02 \x01(\rR\tbyteStart\x12\x18\n" + 1103 1103 + "\abyteEnd\x18\x03 \x01(\rR\abyteEnd\"\x16\n" + 1104 1104 + "\x04Mute\x12\x0e\n" + 1105 1105 + "\x02id\x18\x01 \x01(\rR\x02id\"\x18\n" + 1106 1106 + "\x06Unmute\x12\x0e\n" + 1107 1107 + "\x02id\x18\x01 \x01(\rR\x02id\"O\n" + 1108 1108 + "\x03Set\x12\x12\n" + 1109 1109 + "\x04nick\x18\x01 \x01(\tR\x04nick\x12\x1e\n" + 1110 1110 + "\n" + 1111 1111 + "externalID\x18\x02 \x01(\tR\n" + 1112 1112 + "externalID\x12\x14\n" + 1113 1113 + "\x05color\x18\x03 \x01(\rR\x05color\"9\n" + 1114 1114 + "\x03Get\x12\x14\n" + 1115 1115 + "\x05topic\x18\x01 \x01(\tR\x05topic\x12\x1c\n" + 1116 1116 + "\tconnected\x18\x02 \x01(\rR\tconnected\">\n" + 1117 1117 + "\x04Sudo\x12\x1e\n" + 1118 1118 + "\n" + 1119 1119 + "externalID\x18\x01 \x01(\tR\n" + 1120 1120 + "externalID\x12\x16\n" + 1121 1121 + "\x06secret\x18\x02 \x01(\tR\x06secret\"=\n" + 1122 1122 + "\x04Kick\x12%\n" + 1123 1123 + "\n" + 1124 1124 + "privileges\x18\x01 \x01(\v2\x05.SudoR\n" + 1125 1125 + "privileges\x12\x0e\n" + 1126 1126 + "\x02id\x18\x02 \x01(\rR\x02id\"\x15\n" + 1127 1127 + "\x03Hug\x12\x0e\n" + 1128 1128 + "\x02id\x18\x01 \x01(\rR\x02id\"<\n" + 1129 1129 + "\x03Ban\x12%\n" + 1130 1130 + "\n" + 1131 1131 + "privileges\x18\x01 \x01(\v2\x05.SudoR\n" + 1132 1132 + "privileges\x12\x0e\n" + 1133 1133 + "\x02id\x18\x02 \x01(\rR\x02id\">\n" + 1134 1134 + "\x05Unban\x12%\n" + 1135 1135 + "\n" + 1136 1136 + "privileges\x18\x01 \x01(\v2\x05.SudoR\n" + 1137 1137 + "privileges\x12\x0e\n" + 1138 1138 + "\x02id\x18\x02 \x01(\rR\x02idB3Z1github.com/rachel-mp4/lrcproto/gen/go/lrcpb;lrcpbb\x06proto3" 1139 1139 + 1140 1140 + var ( 1141 1141 + file_lrc_proto_rawDescOnce sync.Once 1142 1142 + file_lrc_proto_rawDescData []byte 1143 1143 + ) 1144 1144 + 1145 1145 + func file_lrc_proto_rawDescGZIP() []byte { 1146 1146 + file_lrc_proto_rawDescOnce.Do(func() { 1147 1147 + file_lrc_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_lrc_proto_rawDesc), len(file_lrc_proto_rawDesc))) 1148 1148 + }) 1149 1149 + return file_lrc_proto_rawDescData 1150 1150 + } 1151 1151 + 1152 1152 + var file_lrc_proto_msgTypes = make([]protoimpl.MessageInfo, 16) 1153 1153 + var file_lrc_proto_goTypes = []any{ 1154 1154 + (*Event)(nil), // 0: Event 1155 1155 + (*Ping)(nil), // 1: Ping 1156 1156 + (*Pong)(nil), // 2: Pong 1157 1157 + (*Init)(nil), // 3: Init 1158 1158 + (*Pub)(nil), // 4: Pub 1159 1159 + (*Insert)(nil), // 5: Insert 1160 1160 + (*Delete)(nil), // 6: Delete 1161 1161 + (*Mute)(nil), // 7: Mute 1162 1162 + (*Unmute)(nil), // 8: Unmute 1163 1163 + (*Set)(nil), // 9: Set 1164 1164 + (*Get)(nil), // 10: Get 1165 1165 + (*Sudo)(nil), // 11: Sudo 1166 1166 + (*Kick)(nil), // 12: Kick 1167 1167 + (*Hug)(nil), // 13: Hug 1168 1168 + (*Ban)(nil), // 14: Ban 1169 1169 + (*Unban)(nil), // 15: Unban 1170 1170 + } 1171 1171 + var file_lrc_proto_depIdxs = []int32{ 1172 1172 + 1, // 0: Event.ping:type_name -> Ping 1173 1173 + 2, // 1: Event.pong:type_name -> Pong 1174 1174 + 3, // 2: Event.init:type_name -> Init 1175 1175 + 4, // 3: Event.pub:type_name -> Pub 1176 1176 + 5, // 4: Event.insert:type_name -> Insert 1177 1177 + 6, // 5: Event.delete:type_name -> Delete 1178 1178 + 7, // 6: Event.mute:type_name -> Mute 1179 1179 + 8, // 7: Event.unmute:type_name -> Unmute 1180 1180 + 9, // 8: Event.set:type_name -> Set 1181 1181 + 10, // 9: Event.get:type_name -> Get 1182 1182 + 12, // 10: Event.kick:type_name -> Kick 1183 1183 + 13, // 11: Event.hug:type_name -> Hug 1184 1184 + 14, // 12: Event.ban:type_name -> Ban 1185 1185 + 15, // 13: Event.unban:type_name -> Unban 1186 1186 + 11, // 14: Kick.privileges:type_name -> Sudo 1187 1187 + 11, // 15: Ban.privileges:type_name -> Sudo 1188 1188 + 11, // 16: Unban.privileges:type_name -> Sudo 1189 1189 + 17, // [17:17] is the sub-list for method output_type 1190 1190 + 17, // [17:17] is the sub-list for method input_type 1191 1191 + 17, // [17:17] is the sub-list for extension type_name 1192 1192 + 17, // [17:17] is the sub-list for extension extendee 1193 1193 + 0, // [0:17] is the sub-list for field type_name 1194 1194 + } 1195 1195 + 1196 1196 + func init() { file_lrc_proto_init() } 1197 1197 + func file_lrc_proto_init() { 1198 1198 + if File_lrc_proto != nil { 1199 1199 + return 1200 1200 + } 1201 1201 + file_lrc_proto_msgTypes[0].OneofWrappers = []any{ 1202 1202 + (*Event_Ping)(nil), 1203 1203 + (*Event_Pong)(nil), 1204 1204 + (*Event_Init)(nil), 1205 1205 + (*Event_Pub)(nil), 1206 1206 + (*Event_Insert)(nil), 1207 1207 + (*Event_Delete)(nil), 1208 1208 + (*Event_Mute)(nil), 1209 1209 + (*Event_Unmute)(nil), 1210 1210 + (*Event_Set)(nil), 1211 1211 + (*Event_Get)(nil), 1212 1212 + (*Event_Kick)(nil), 1213 1213 + (*Event_Hug)(nil), 1214 1214 + (*Event_Ban)(nil), 1215 1215 + (*Event_Unban)(nil), 1216 1216 + } 1217 1217 + type x struct{} 1218 1218 + out := protoimpl.TypeBuilder{ 1219 1219 + File: protoimpl.DescBuilder{ 1220 1220 + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 1221 1221 + RawDescriptor: unsafe.Slice(unsafe.StringData(file_lrc_proto_rawDesc), len(file_lrc_proto_rawDesc)), 1222 1222 + NumEnums: 0, 1223 1223 + NumMessages: 16, 1224 1224 + NumExtensions: 0, 1225 1225 + NumServices: 0, 1226 1226 + }, 1227 1227 + GoTypes: file_lrc_proto_goTypes, 1228 1228 + DependencyIndexes: file_lrc_proto_depIdxs, 1229 1229 + MessageInfos: file_lrc_proto_msgTypes, 1230 1230 + }.Build() 1231 1231 + File_lrc_proto = out.File 1232 1232 + file_lrc_proto_goTypes = nil 1233 1233 + file_lrc_proto_depIdxs = nil 1234 1234 + }

+5

go.mod

··· 1 1 + module github.com/rachel-mp4/lrcproto 2 2 + 3 3 + go 1.24.2 4 4 + 5 5 + require google.golang.org/protobuf v1.36.6

+6

go.sum

··· 1 1 + github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= 2 2 + github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= 3 3 + golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= 4 4 + golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= 5 5 + google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= 6 6 + google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=

+2

lrc.proto

··· 1 1 syntax = "proto3"; 2 2 3 3 + option go_package = "github.com/rachel-mp4/lrcproto/gen/go/lrcpb;lrcpb"; 4 4 + 3 5 message Event { 4 6 oneof msg { 5 7 Ping ping = 1;