1/*eslint-disable block-scoped-var, no-redeclare, no-control-regex, no-prototype-builtins*/ 2(function($protobuf) { 3 "use strict"; 4 5 // Common aliases 6 var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util; 7 8 // Exported root namespace 9 var $root = $protobuf.roots["push-server"] || ($protobuf.roots["push-server"] = {}); 10 11 $root.RequestBatch = (function() { 12 13 /** 14 * Properties of a RequestBatch. 15 * @exports IRequestBatch 16 * @interface IRequestBatch 17 * @property {Array.<Request>|null} [requests] RequestBatch requests 18 */ 19 20 /** 21 * Constructs a new RequestBatch. 22 * @exports RequestBatch 23 * @classdesc Represents a RequestBatch. 24 * @implements IRequestBatch 25 * @constructor 26 * @param {IRequestBatch=} [properties] Properties to set 27 */ 28 function RequestBatch(properties) { 29 this.requests = []; 30 if (properties) 31 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 32 if (properties[keys[i]] != null) 33 this[keys[i]] = properties[keys[i]]; 34 } 35 36 /** 37 * RequestBatch requests. 38 * @member {Array.<Request>} requests 39 * @memberof RequestBatch 40 * @instance 41 */ 42 RequestBatch.prototype.requests = $util.emptyArray; 43 44 /** 45 * Creates a new RequestBatch instance using the specified properties. 46 * @function create 47 * @memberof RequestBatch 48 * @static 49 * @param {IRequestBatch=} [properties] Properties to set 50 * @returns {RequestBatch} RequestBatch instance 51 */ 52 RequestBatch.create = function create(properties) { 53 return new RequestBatch(properties); 54 }; 55 56 /** 57 * Encodes the specified RequestBatch message. Does not implicitly {@link RequestBatch.verify|verify} messages. 58 * @function encode 59 * @memberof RequestBatch 60 * @static 61 * @param {RequestBatch} message RequestBatch message or plain object to encode 62 * @param {$protobuf.Writer} [writer] Writer to encode to 63 * @returns {$protobuf.Writer} Writer 64 */ 65 RequestBatch.encode = function encode(message, writer) { 66 if (!writer) 67 writer = $Writer.create(); 68 if (message.requests != null && message.requests.length) 69 for (var i = 0; i < message.requests.length; ++i) 70 $root.Request.encode(message.requests[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); 71 return writer; 72 }; 73 74 /** 75 * Decodes a RequestBatch message from the specified reader or buffer. 76 * @function decode 77 * @memberof RequestBatch 78 * @static 79 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 80 * @param {number} [length] Message length if known beforehand 81 * @returns {RequestBatch} RequestBatch 82 * @throws {Error} If the payload is not a reader or valid buffer 83 * @throws {$protobuf.util.ProtocolError} If required fields are missing 84 */ 85 RequestBatch.decode = function decode(reader, length) { 86 if (!(reader instanceof $Reader)) 87 reader = $Reader.create(reader); 88 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.RequestBatch(); 89 while (reader.pos < end) { 90 var tag = reader.uint32(); 91 switch (tag >>> 3) { 92 case 1: 93 if (!(message.requests && message.requests.length)) 94 message.requests = []; 95 message.requests.push($root.Request.decode(reader, reader.uint32())); 96 break; 97 default: 98 reader.skipType(tag & 7); 99 break; 100 } 101 } 102 return message; 103 }; 104 105 return RequestBatch; 106 })(); 107 108 $root.Request = (function() { 109 110 /** 111 * Properties of a Request. 112 * @exports IRequest 113 * @interface IRequest 114 * @property {IncomingMessagesRequest|null} [incomingMessages] Request incomingMessages 115 * @property {ChannelStatsRequest|null} [channelStats] Request channelStats 116 * @property {ServerStatsRequest|null} [serverStats] Request serverStats 117 */ 118 119 /** 120 * Constructs a new Request. 121 * @exports Request 122 * @classdesc Represents a Request. 123 * @implements IRequest 124 * @constructor 125 * @param {IRequest=} [properties] Properties to set 126 */
127 function Request(properties) { 128 if (properties) 129 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 130 if (properties[keys[i]] != null) 131 this[keys[i]] = properties[keys[i]]; 132 } 133 134 /** 135 * Request incomingMessages. 136 * @member {IncomingMessagesRequest|null|undefined} incomingMessages 137 * @memberof Request 138 * @instance 139 */ 140 Request.prototype.incomingMessages = null; 141 142 /** 143 * Request channelStats. 144 * @member {ChannelStatsRequest|null|undefined} channelStats 145 * @memberof Request 146 * @instance 147 */ 148 Request.prototype.channelStats = null; 149 150 /** 151 * Request serverStats. 152 * @member {ServerStatsRequest|null|undefined} serverStats 153 * @memberof Request 154 * @instance 155 */ 156 Request.prototype.serverStats = null; 157 158 // OneOf field names bound to virtual getters and setters 159 var $oneOfFields; 160 161 /** 162 * Request command. 163 * @member {"incomingMessages"|"channelStats"|"serverStats"|undefined} command 164 * @memberof Request 165 * @instance 166 */ 167 Object.defineProperty(Request.prototype, "command", { 168 get: $util.oneOfGetter($oneOfFields = ["incomingMessages", "channelStats", "serverStats"]), 169 set: $util.oneOfSetter($oneOfFields) 170 }); 171 172 /** 173 * Creates a new Request instance using the specified properties. 174 * @function create 175 * @memberof Request 176 * @static 177 * @param {IRequest=} [properties] Properties to set 178 * @returns {Request} Request instance 179 */ 180 Request.create = function create(properties) { 181 return new Request(properties); 182 }; 183 184 /** 185 * Encodes the specified Request message. Does not implicitly {@link Request.verify|verify} messages. 186 * @function encode 187 * @memberof Request 188 * @static 189 * @param {Request} message Request message or plain object to encode 190 * @param {$protobuf.Writer} [writer] Writer to encode to 191 * @returns {$protobuf.Writer} Writer 192 */ 193 Request.encode = function encode(message, writer) { 194 if (!writer) 195 writer = $Writer.create(); 196 if (message.incomingMessages != null && message.hasOwnProperty("incomingMessages")) 197 $root.IncomingMessagesRequest.encode(message.incomingMessages, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); 198 if (message.channelStats != null && message.hasOwnProperty("channelStats")) 199 $root.ChannelStatsRequest.encode(message.channelStats, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); 200 if (message.serverStats != null && message.hasOwnProperty("serverStats")) 201 $root.ServerStatsRequest.encode(message.serverStats, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); 202 return writer; 203 }; 204 205 /** 206 * Decodes a Request message from the specified reader or buffer. 207 * @function decode 208 * @memberof Request 209 * @static 210 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 211 * @param {number} [length] Message length if known beforehand 212 * @returns {Request} Request 213 * @throws {Error} If the payload is not a reader or valid buffer 214 * @throws {$protobuf.util.ProtocolError} If required fields are missing 215 */ 216 Request.decode = function decode(reader, length) { 217 if (!(reader instanceof $Reader)) 218 reader = $Reader.create(reader); 219 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.Request(); 220 while (reader.pos < end) { 221 var tag = reader.uint32(); 222 switch (tag >>> 3) { 223 case 1: 224 message.incomingMessages = $root.IncomingMessagesRequest.decode(reader, reader.uint32()); 225 break; 226 case 2: 227 message.channelStats = $root.ChannelStatsRequest.decode(reader, reader.uint32()); 228 break; 229 case 3: 230 message.serverStats = $root.ServerStatsRequest.decode(reader, reader.uint32()); 231 break; 232 default: 233 reader.skipType(tag & 7); 234 break; 235 } 236 } 237 return message; 238 }; 239 240 return Request; 241 })(); 242 243 $root.IncomingMessagesRequest = (function() { 244 245 /** 246 * Properties of an IncomingMessagesRequest. 247 * @exports IIncomingMessagesRequest 248 * @interface IIncomingMessagesRequest 249 * @property {Array.<IncomingMessage>|null} [messages] IncomingMessagesRequest messages 250 */ 251 252 /** 253 * Constructs a new IncomingMessagesRequest. 254 * @exports IncomingMessagesRequest 255 * @classdesc Represents an IncomingMessagesRequest. 256 * @implements IIncomingMessagesRequest 257 * @constructor 258 * @param {IIncomingMessagesRequest=} [properties] Properties to set 259 */ 260 function IncomingMessagesRequest(properties) { 261 this.messages = []; 262 if (properties) 263 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 264 if (properties[keys[i]] != null) 265 this[keys[i]] = properties[keys[i]]; 266 } 267 268 /** 269 * IncomingMessagesRequest messages. 270 * @member {Array.<IncomingMessage>} messages 271 * @memberof IncomingMessagesRequest 272 * @instance 273 */ 274 IncomingMessagesRequest.prototype.messages = $util.emptyArray; 275 276 /** 277 * Creates a new IncomingMessagesRequest instance using the specified properties. 278 * @function create 279 * @memberof IncomingMessagesRequest 280 * @static 281 * @param {IIncomingMessagesRequest=} [properties] Properties to set 282 * @returns {IncomingMessagesRequest} IncomingMessagesRequest instance 283 */ 284 IncomingMessagesRequest.create = function create(properties) { 285 return new IncomingMessagesRequest(properties); 286 }; 287 288 /** 289 * Encodes the specified IncomingMessagesRequest message. Does not implicitly {@link IncomingMessagesRequest.verify|verify} messages. 290 * @function encode 291 * @memberof IncomingMessagesRequest 292 * @static 293 * @param {IncomingMessagesRequest} message IncomingMessagesRequest message or plain object to encode 294 * @param {$protobuf.Writer} [writer] Writer to encode to 295 * @returns {$protobuf.Writer} Writer 296 */ 297 IncomingMessagesRequest.encode = function encode(message, writer) { 298 if (!writer) 299 writer = $Writer.create(); 300 if (message.messages != null && message.messages.length) 301 for (var i = 0; i < message.messages.length; ++i) 302 $root.IncomingMessage.encode(message.messages[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); 303 return writer; 304 }; 305 306 /** 307 * Decodes an IncomingMessagesRequest message from the specified reader or buffer. 308 * @function decode 309 * @memberof IncomingMessagesRequest 310 * @static 311 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 312 * @param {number} [length] Message length if known beforehand 313 * @returns {IncomingMessagesRequest} IncomingMessagesRequest 314 * @throws {Error} If the payload is not a reader or valid buffer 315 * @throws {$protobuf.util.ProtocolError} If required fields are missing 316 */ 317 IncomingMessagesRequest.decode = function decode(reader, length) { 318 if (!(reader instanceof $Reader)) 319 reader = $Reader.create(reader); 320 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.IncomingMessagesRequest(); 321 while (reader.pos < end) { 322 var tag = reader.uint32(); 323 switch (tag >>> 3) { 324 case 1: 325 if (!(message.messages && message.messages.length)) 326 message.messages = []; 327 message.messages.push($root.IncomingMessage.decode(reader, reader.uint32())); 328 break; 329 default: 330 reader.skipType(tag & 7); 331 break; 332 } 333 } 334 return message; 335 }; 336 337 return IncomingMessagesRequest; 338 })(); 339 340 $root.IncomingMessage = (function() { 341 342 /** 343 * Properties of an IncomingMessage. 344 * @exports IIncomingMessage 345 * @interface IIncomingMessage 346 * @property {Array.<Receiver>|null} [receivers] IncomingMessage receivers 347 * @property {Sender|null} [sender] IncomingMessage sender 348 * @property {string|null} [body] IncomingMessage body 349 * @property {number|null} [expiry] IncomingMessage expiry 350 * @property {string|null} [type] IncomingMessage type 351 */ 352 353 /** 354 * Constructs a new IncomingMessage. 355 * @exports IncomingMessage 356 * @classdesc Represents an IncomingMessage. 357 * @implements IIncomingMessage 358 * @constructor 359 * @param {IIncomingMessage=} [properties] Properties to set 360 */ 361 function IncomingMessage(properties) { 362 this.receivers = []; 363 if (properties) 364 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 365 if (properties[keys[i]] != null) 366 this[keys[i]] = properties[keys[i]]; 367 } 368 369 /** 370 * IncomingMessage receivers. 371 * @member {Array.<Receiver>} receivers 372 * @memberof IncomingMessage 373 * @instance 374 */ 375 IncomingMessage.prototype.receivers = $util.emptyArray; 376 377 /** 378 * IncomingMessage sender. 379 * @member {Sender|null|undefined} sender 380 * @memberof IncomingMessage 381 * @instance 382 */ 383 IncomingMessage.prototype.sender = null; 384 385 /** 386 * IncomingMessage body. 387 * @member {string} body 388 * @memberof IncomingMessage 389 * @instance 390 */ 391 IncomingMessage.prototype.body = ""; 392 393 /** 394 * IncomingMessage expiry. 395 * @member {number} expiry 396 * @memberof IncomingMessage 397 * @instance 398 */ 399 IncomingMessage.prototype.expiry = 0; 400 401 /** 402 * IncomingMessage type. 403 * @member {string} type 404 * @memberof IncomingMessage 405 * @instance 406 */ 407 IncomingMessage.prototype.type = ""; 408 409 /** 410 * Creates a new IncomingMessage instance using the specified properties. 411 * @function create 412 * @memberof IncomingMessage 413 * @static 414 * @param {IIncomingMessage=} [properties] Properties to set 415 * @returns {IncomingMessage} IncomingMessage instance 416 */ 417 IncomingMessage.create = function create(properties) { 418 return new IncomingMessage(properties); 419 }; 420 421 /** 422 * Encodes the specified IncomingMessage message. Does not implicitly {@link IncomingMessage.verify|verify} messages. 423 * @function encode 424 * @memberof IncomingMessage 425 * @static 426 * @param {IncomingMessage} message IncomingMessage message or plain object to encode 427 * @param {$protobuf.Writer} [writer] Writer to encode to 428 * @returns {$protobuf.Writer} Writer 429 */ 430 IncomingMessage.encode = function encode(message, writer) { 431 if (!writer) 432 writer = $Writer.create(); 433 if (message.receivers != null && message.receivers.length) 434 for (var i = 0; i < message.receivers.length; ++i) 435 $root.Receiver.encode(message.receivers[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); 436 if (message.sender != null && message.hasOwnProperty("sender")) 437 $root.Sender.encode(message.sender, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); 438 if (message.body != null && message.hasOwnProperty("body")) 439 writer.uint32(/* id 3, wireType 2 =*/26).string(message.body); 440 if (message.expiry != null && message.hasOwnProperty("expiry")) 441 writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.expiry); 442 if (message.type != null && message.hasOwnProperty("type")) 443 writer.uint32(/* id 5, wireType 2 =*/42).string(message.type); 444 return writer; 445 }; 446 447 /** 448 * Decodes an IncomingMessage message from the specified reader or buffer. 449 * @function decode 450 * @memberof IncomingMessage 451 * @static 452 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 453 * @param {number} [length] Message length if known beforehand 454 * @returns {IncomingMessage} IncomingMessage 455 * @throws {Error} If the payload is not a reader or valid buffer 456 * @throws {$protobuf.util.ProtocolError} If required fields are missing 457 */ 458 IncomingMessage.decode = function decode(reader, length) { 459 if (!(reader instanceof $Reader)) 460 reader = $Reader.create(reader); 461 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.IncomingMessage(); 462 while (reader.pos < end) { 463 var tag = reader.uint32(); 464 switch (tag >>> 3) { 465 case 1: 466 if (!(message.receivers && message.receivers.length)) 467 message.receivers = []; 468 message.receivers.push($root.Receiver.decode(reader, reader.uint32())); 469 break; 470 case 2: 471 message.sender = $root.Sender.decode(reader, reader.uint32()); 472 break; 473 case 3: 474 message.body = reader.string(); 475 break; 476 case 4: 477 message.expiry = reader.uint32(); 478 break; 479 case 5: 480 message.type = reader.string(); 481 break; 482 default: 483 reader.skipType(tag & 7); 484 break; 485 } 486 } 487 return message; 488 }; 489 490 return IncomingMessage; 491 })(); 492 493 $root.ChannelStatsRequest = (function() { 494 495 /** 496 * Properties of a ChannelStatsRequest.
497 * @exports IChannelStatsRequest 498 * @interface IChannelStatsRequest 499 * @property {Array.<ChannelId>|null} [channels] ChannelStatsRequest channels 500 */ 501 502 /** 503 * Constructs a new ChannelStatsRequest. 504 * @exports ChannelStatsRequest 505 * @classdesc Represents a ChannelStatsRequest. 506 * @implements IChannelStatsRequest 507 * @constructor 508 * @param {IChannelStatsRequest=} [properties] Properties to set 509 */ 510 function ChannelStatsRequest(properties) { 511 this.channels = []; 512 if (properties) 513 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 514 if (properties[keys[i]] != null) 515 this[keys[i]] = properties[keys[i]]; 516 } 517 518 /** 519 * ChannelStatsRequest channels. 520 * @member {Array.<ChannelId>} channels 521 * @memberof ChannelStatsRequest 522 * @instance 523 */ 524 ChannelStatsRequest.prototype.channels = $util.emptyArray; 525 526 /** 527 * Creates a new ChannelStatsRequest instance using the specified properties. 528 * @function create 529 * @memberof ChannelStatsRequest 530 * @static 531 * @param {IChannelStatsRequest=} [properties] Properties to set 532 * @returns {ChannelStatsRequest} ChannelStatsRequest instance 533 */ 534 ChannelStatsRequest.create = function create(properties) { 535 return new ChannelStatsRequest(properties); 536 }; 537 538 /** 539 * Encodes the specified ChannelStatsRequest message. Does not implicitly {@link ChannelStatsRequest.verify|verify} messages. 540 * @function encode 541 * @memberof ChannelStatsRequest 542 * @static 543 * @param {ChannelStatsRequest} message ChannelStatsRequest message or plain object to encode 544 * @param {$protobuf.Writer} [writer] Writer to encode to 545 * @returns {$protobuf.Writer} Writer 546 */ 547 ChannelStatsRequest.encode = function encode(message, writer) { 548 if (!writer) 549 writer = $Writer.create(); 550 if (message.channels != null && message.channels.length) 551 for (var i = 0; i < message.channels.length; ++i) 552 $root.ChannelId.encode(message.channels[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); 553 return writer; 554 }; 555 556 /** 557 * Decodes a ChannelStatsRequest message from the specified reader or buffer. 558 * @function decode 559 * @memberof ChannelStatsRequest 560 * @static 561 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 562 * @param {number} [length] Message length if known beforehand 563 * @returns {ChannelStatsRequest} ChannelStatsRequest 564 * @throws {Error} If the payload is not a reader or valid buffer 565 * @throws {$protobuf.util.ProtocolError} If required fields are missing 566 */ 567 ChannelStatsRequest.decode = function decode(reader, length) { 568 if (!(reader instanceof $Reader)) 569 reader = $Reader.create(reader); 570 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelStatsRequest(); 571 while (reader.pos < end) { 572 var tag = reader.uint32(); 573 switch (tag >>> 3) { 574 case 1: 575 if (!(message.channels && message.channels.length)) 576 message.channels = []; 577 message.channels.push($root.ChannelId.decode(reader, reader.uint32())); 578 break; 579 default: 580 reader.skipType(tag & 7); 581 break; 582 } 583 } 584 return message; 585 }; 586 587 return ChannelStatsRequest; 588 })(); 589 590 $root.ChannelId = (function() { 591 592 /** 593 * Properties of a ChannelId. 594 * @exports IChannelId 595 * @interface IChannelId 596 * @property {Uint8Array|null} [id] ChannelId id 597 * @property {boolean|null} [isPrivate] ChannelId isPrivate 598 * @property {Uint8Array|null} [signature] ChannelId signature 599 */ 600 601 /** 602 * Constructs a new ChannelId. 603 * @exports ChannelId 604 * @classdesc Represents a ChannelId. 605 * @implements IChannelId 606 * @constructor 607 * @param {IChannelId=} [properties] Properties to set 608 */ 609 function ChannelId(properties) { 610 if (properties) 611 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 612 if (properties[keys[i]] != null) 613 this[keys[i]] = properties[keys[i]]; 614 } 615 616 /** 617 * ChannelId id. 618 * @member {Uint8Array} id 619 * @memberof ChannelId 620 * @instance 621 */ 622 ChannelId.prototype.id = $util.newBuffer([]); 623 624 /** 625 * ChannelId isPrivate. 626 * @member {boolean} isPrivate 627 * @memberof ChannelId 628 * @instance 629 */ 630 ChannelId.prototype.isPrivate = false;
631 632 /** 633 * ChannelId signature. 634 * @member {Uint8Array} signature 635 * @memberof ChannelId 636 * @instance 637 */ 638 ChannelId.prototype.signature = $util.newBuffer([]); 639 640 /** 641 * Creates a new ChannelId instance using the specified properties. 642 * @function create 643 * @memberof ChannelId 644 * @static 645 * @param {IChannelId=} [properties] Properties to set 646 * @returns {ChannelId} ChannelId instance 647 */ 648 ChannelId.create = function create(properties) { 649 return new ChannelId(properties); 650 }; 651 652 /** 653 * Encodes the specified ChannelId message. Does not implicitly {@link ChannelId.verify|verify} messages. 654 * @function encode 655 * @memberof ChannelId 656 * @static 657 * @param {ChannelId} message ChannelId message or plain object to encode 658 * @param {$protobuf.Writer} [writer] Writer to encode to 659 * @returns {$protobuf.Writer} Writer 660 */ 661 ChannelId.encode = function encode(message, writer) { 662 if (!writer) 663 writer = $Writer.create(); 664 if (message.id != null && message.hasOwnProperty("id")) 665 writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.id); 666 if (message.isPrivate != null && message.hasOwnProperty("isPrivate")) 667 writer.uint32(/* id 2, wireType 0 =*/16).bool(message.isPrivate); 668 if (message.signature != null && message.hasOwnProperty("signature")) 669 writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.signature); 670 return writer; 671 }; 672 673 /** 674 * Decodes a ChannelId message from the specified reader or buffer. 675 * @function decode 676 * @memberof ChannelId 677 * @static 678 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 679 * @param {number} [length] Message length if known beforehand 680 * @returns {ChannelId} ChannelId 681 * @throws {Error} If the payload is not a reader or valid buffer 682 * @throws {$protobuf.util.ProtocolError} If required fields are missing 683 */ 684 ChannelId.decode = function decode(reader, length) { 685 if (!(reader instanceof $Reader)) 686 reader = $Reader.create(reader); 687 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelId(); 688 while (reader.pos < end) { 689 var tag = reader.uint32(); 690 switch (tag >>> 3) { 691 case 1: 692 message.id = reader.bytes(); 693 break; 694 case 2: 695 message.isPrivate = reader.bool(); 696 break; 697 case 3: 698 message.signature = reader.bytes(); 699 break; 700 default: 701 reader.skipType(tag & 7); 702 break; 703 } 704 } 705 return message; 706 }; 707 708 return ChannelId; 709 })(); 710 711 $root.ServerStatsRequest = (function() { 712 713 /** 714 * Properties of a ServerStatsRequest. 715 * @exports IServerStatsRequest 716 * @interface IServerStatsRequest 717 */ 718 719 /** 720 * Constructs a new ServerStatsRequest. 721 * @exports ServerStatsRequest 722 * @classdesc Represents a ServerStatsRequest. 723 * @implements IServerStatsRequest 724 * @constructor 725 * @param {IServerStatsRequest=} [properties] Properties to set 726 */ 727 function ServerStatsRequest(properties) { 728 if (properties) 729 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 730 if (properties[keys[i]] != null) 731 this[keys[i]] = properties[keys[i]]; 732 } 733 734 /** 735 * Creates a new ServerStatsRequest instance using the specified properties. 736 * @function create 737 * @memberof ServerStatsRequest 738 * @static 739 * @param {IServerStatsRequest=} [properties] Properties to set 740 * @returns {ServerStatsRequest} ServerStatsRequest instance 741 */ 742 ServerStatsRequest.create = function create(properties) { 743 return new ServerStatsRequest(properties); 744 }; 745 746 /** 747 * Encodes the specified ServerStatsRequest message. Does not implicitly {@link ServerStatsRequest.verify|verify} messages. 748 * @function encode 749 * @memberof ServerStatsRequest 750 * @static 751 * @param {ServerStatsRequest} message ServerStatsRequest message or plain object to encode 752 * @param {$protobuf.Writer} [writer] Writer to encode to 753 * @returns {$protobuf.Writer} Writer 754 */ 755 ServerStatsRequest.encode = function encode(message, writer) { 756 if (!writer) 757 writer = $Writer.create(); 758 return writer; 759 }; 760 761 /** 762 * Decodes a ServerStatsRequest message from the specified reader or buffer. 763 * @function decode 764 * @memberof ServerStatsRequest 765 * @static 766 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 767 * @param {number} [length] Message length if known beforehand 768 * @returns {ServerStatsRequest} ServerStatsRequest 769 * @throws {Error} If the payload is not a reader or valid buffer 770 * @throws {$protobuf.util.ProtocolError} If required fields are missing 771 */ 772 ServerStatsRequest.decode = function decode(reader, length) { 773 if (!(reader instanceof $Reader)) 774 reader = $Reader.create(reader); 775 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ServerStatsRequest(); 776 while (reader.pos < end) { 777 var tag = reader.uint32(); 778 switch (tag >>> 3) { 779 default: 780 reader.skipType(tag & 7); 781 break; 782 } 783 } 784 return message; 785 }; 786 787 return ServerStatsRequest; 788 })(); 789 790 $root.Sender = (function() { 791 792 /** 793 * Properties of a Sender. 794 * @exports ISender 795 * @interface ISender 796 * @property {SenderType|null}
796 [type] Sender type 797 * @property {Uint8Array|null} [id] Sender id 798 */ 799 800 /** 801 * Constructs a new Sender. 802 * @exports Sender 803 * @classdesc Represents a Sender. 804 * @implements ISender 805 * @constructor 806 * @param {ISender=} [properties] Properties to set 807 */ 808 function Sender(properties) { 809 if (properties) 810 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 811 if (properties[keys[i]] != null) 812 this[keys[i]] = properties[keys[i]]; 813 } 814 815 /** 816 * Sender type. 817 * @member {SenderType} type 818 * @memberof Sender 819 * @instance 820 */ 821 Sender.prototype.type = 0; 822 823 /** 824 * Sender id. 825 * @member {Uint8Array} id 826 * @memberof Sender 827 * @instance 828 */ 829 Sender.prototype.id = $util.newBuffer([]); 830 831 /** 832 * Creates a new Sender instance using the specified properties. 833 * @function create 834 * @memberof Sender 835 * @static 836 * @param {ISender=} [properties] Properties to set 837 * @returns {Sender} Sender instance 838 */ 839 Sender.create = function create(properties) { 840 return new Sender(properties); 841 }; 842 843 /** 844 * Encodes the specified Sender message. Does not implicitly {@link Sender.verify|verify} messages. 845 * @function encode 846 * @memberof Sender 847 * @static 848 * @param {Sender} message Sender message or plain object to encode 849 * @param {$protobuf.Writer} [writer] Writer to encode to 850 * @returns {$protobuf.Writer} Writer 851 */ 852 Sender.encode = function encode(message, writer) { 853 if (!writer) 854 writer = $Writer.create(); 855 if (message.type != null && message.hasOwnProperty("type")) 856 writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type); 857 if (message.id != null && message.hasOwnProperty("id")) 858 writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.id); 859 return writer; 860 }; 861 862 /** 863 * Decodes a Sender message from the specified reader or buffer. 864 * @function decode 865 * @memberof Sender 866 * @static 867 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 868 * @param {number} [length] Message length if known beforehand 869 * @returns {Sender} Sender 870 * @throws {Error} If the payload is not a reader or valid buffer 871 * @throws {$protobuf.util.ProtocolError} If required fields are missing 872 */ 873 Sender.decode = function decode(reader, length) { 874 if (!(reader instanceof $Reader)) 875 reader = $Reader.create(reader); 876 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.Sender(); 877 while (reader.pos < end) { 878 var tag = reader.uint32(); 879 switch (tag >>> 3) { 880 case 1: 881 message.type = reader.int32(); 882 break; 883 case 2: 884 message.id = reader.bytes(); 885 break; 886 default: 887 reader.skipType(tag & 7); 888 break; 889 } 890 } 891 return message; 892 }; 893 894 return Sender; 895 })(); 896 897 /** 898 * SenderType enum. 899 * @exports SenderType 900 * @enum {string} 901 * @property {number} UNKNOWN=0 UNKNOWN value 902 * @property {number} CLIENT=1 CLIENT value 903 * @property {number} BACKEND=2 BACKEND value 904 */ 905 $root.SenderType = (function() { 906 var valuesById = {}, values = Object.create(valuesById); 907 values[valuesById[0] = "UNKNOWN"] = 0; 908 values[valuesById[1] = "CLIENT"] = 1; 909 values[valuesById[2] = "BACKEND"] = 2; 910 return values; 911 })(); 912 913 $root.Receiver = (function() { 914 915 /** 916 * Properties of a Receiver. 917 * @exports IReceiver 918 * @interface IReceiver 919 * @property {Uint8Array|null} [id] Receiver id 920 * @property {boolean|null} [isPrivate] Receiver isPrivate 921 * @property {Uint8Array|null} [signature] Receiver signature 922 */ 923 924 /** 925 * Constructs a new Receiver. 926 * @exports Receiver 927 * @classdesc Represents a Receiver. 928 * @implements IReceiver 929 * @constructor 930 * @param {IReceiver=} [properties] Properties to set 931 */ 932 function Receiver(properties) { 933 if (properties) 934 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 935 if (properties[keys[i]] != null) 936 this[keys[i]] = properties[keys[i]]; 937 } 938 939 /** 940 * Receiver id. 941 * @member {Uint8Array} id 942 * @memberof Receiver 943 * @instance 944 */ 945 Receiver.prototype.id = $util.newBuffer([]); 946 947 /** 948 * Receiver isPrivate. 949 * @member {boolean} isPrivate 950 * @memberof Receiver 951 * @instance 952 */ 953 Receiver.prototype.isPrivate = false;
954 955 /** 956 * Receiver signature. 957 * @member {Uint8Array} signature 958 * @memberof Receiver 959 * @instance 960 */ 961 Receiver.prototype.signature = $util.newBuffer([]); 962 963 /** 964 * Creates a new Receiver instance using the specified properties. 965 * @function create 966 * @memberof Receiver 967 * @static 968 * @param {IReceiver=} [properties] Properties to set 969 * @returns {Receiver} Receiver instance 970 */ 971 Receiver.create = function create(properties) { 972 return new Receiver(properties); 973 }; 974 975 /** 976 * Encodes the specified Receiver message. Does not implicitly {@link Receiver.verify|verify} messages. 977 * @function encode 978 * @memberof Receiver 979 * @static 980 * @param {Receiver} message Receiver message or plain object to encode 981 * @param {$protobuf.Writer} [writer] Writer to encode to 982 * @returns {$protobuf.Writer} Writer 983 */ 984 Receiver.encode = function encode(message, writer) { 985 if (!writer) 986 writer = $Writer.create(); 987 if (message.id != null && message.hasOwnProperty("id")) 988 writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.id); 989 if (message.isPrivate != null && message.hasOwnProperty("isPrivate")) 990 writer.uint32(/* id 2, wireType 0 =*/16).bool(message.isPrivate); 991 if (message.signature != null && message.hasOwnProperty("signature")) 992 writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.signature); 993 return writer; 994 }; 995 996 /** 997 * Decodes a Receiver message from the specified reader or buffer. 998 * @function decode 999 * @memberof Receiver 1000 * @static 1001 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 1002 * @param {number} [length] Message length if known beforehand 1003 * @returns {Receiver} Receiver 1004 * @throws {Error} If the payload is not a reader or valid buffer 1005 * @throws {$protobuf.util.ProtocolError} If required fields are missing 1006 */ 1007 Receiver.decode = function decode(reader, length) { 1008 if (!(reader instanceof $Reader)) 1009 reader = $Reader.create(reader); 1010 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.Receiver(); 1011 while (reader.pos < end) { 1012 var tag = reader.uint32(); 1013 switch (tag >>> 3) { 1014 case 1: 1015 message.id = reader.bytes(); 1016 break; 1017 case 2: 1018 message.isPrivate = reader.bool(); 1019 break; 1020 case 3: 1021 message.signature = reader.bytes(); 1022 break; 1023 default: 1024 reader.skipType(tag & 7); 1025 break; 1026 } 1027 } 1028 return message; 1029 }; 1030 1031 return Receiver; 1032 })(); 1033 1034 $root.ResponseBatch = (function() { 1035 1036 /** 1037 * Properties of a ResponseBatch. 1038 * @exports IResponseBatch 1039 * @interface IResponseBatch 1040 * @property {Array.<Response>|null} [responses] ResponseBatch responses 1041 */ 1042 1043 /** 1044 * Constructs a new ResponseBatch. 1045 * @exports ResponseBatch 1046 * @classdesc Represents a ResponseBatch. 1047 * @implements IResponseBatch 1048 * @constructor 1049 * @param {IResponseBatch=} [properties] Properties to set 1050 */ 1051 function ResponseBatch(properties) { 1052 this.responses = []; 1053 if (properties) 1054 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 1055 if (properties[keys[i]] != null) 1056 this[keys[i]] = properties[keys[i]]; 1057 } 1058 1059 /** 1060 * ResponseBatch responses. 1061 * @member {Array.<Response>} responses 1062 * @memberof ResponseBatch 1063 * @instance 1064 */ 1065 ResponseBatch.prototype.responses = $util.emptyArray; 1066 1067 /** 1068 * Creates a new ResponseBatch instance using the specified properties. 1069 * @function create 1070 * @memberof ResponseBatch 1071 * @static 1072 * @param {IResponseBatch=} [properties] Properties to set 1073 * @returns {ResponseBatch} ResponseBatch instance 1074 */ 1075 ResponseBatch.create = function create(properties) { 1076 return new ResponseBatch(properties); 1077 }; 1078 1079 /** 1080 * Encodes the specified ResponseBatch message. Does not implicitly {@link ResponseBatch.verify|verify} messages. 1081 * @function encode 1082 * @memberof ResponseBatch 1083 * @static 1084 * @param {ResponseBatch} message ResponseBatch message or plain object to encode 1085 * @param {$protobuf.Writer} [writer] Writer to encode to 1086 * @returns {$protobuf.Writer} Writer 1087 */ 1088 ResponseBatch.encode = function encode(message, writer) { 1089 if (!writer) 1090 writer = $Writer.create(); 1091 if (message.responses != null && message.responses.length) 1092 for (var i = 0; i < message.responses.length; ++i) 1093 $root.Response.encode(message.responses[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); 1094 return writer; 1095 }; 1096 1097 /** 1098 * Decodes a ResponseBatch message from the specified reader or buffer. 1099 * @function decode 1100 * @memberof ResponseBatch 1101 * @static 1102 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 1103 * @param {number} [length] Message length if known beforehand 1104 * @returns {ResponseBatch} ResponseBatch 1105 * @throws {Error} If the payload is not a reader or valid buffer 1106 * @throws {$protobuf.util.ProtocolError} If required fields are missing 1107 */ 1108 ResponseBatch.decode = function decode(reader, length) { 1109 if (!(reader instanceof $Reader)) 1110 reader = $Reader.create(reader); 1111 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ResponseBatch(); 1112 while (reader.pos < end) { 1113 var tag = reader.uint32(); 1114 switch (tag >>> 3) { 1115 case 1: 1116 if (!(message.responses && message.responses.length)) 1117 message.responses = []; 1118 message.responses.push($root.Response.decode(reader, reader.uint32())); 1119 break; 1120 default: 1121 reader.skipType(tag & 7); 1122 break; 1123 } 1124 } 1125 return message; 1126 }; 1127 1128 return ResponseBatch; 1129 })(); 1130 1131 $root.Response = (function() { 1132 1133 /** 1134 * Properties of a Response. 1135 * @exports IResponse 1136 * @interface IResponse 1137 * @property {OutgoingMessagesResponse|null} [outgoingMessages] Response outgoingMessages 1138 * @property {ChannelStatsResponse|null} [channelStats] Response channelStats 1139 * @property {JsonResponse|null} [serverStats] Response serverStats 1140 */ 1141 1142 /** 1143 * Constructs a new Response. 1144 * @exports Response 1145 * @classdesc Represents a Response. 1146 * @implements IResponse 1147 * @constructor 1148 * @param {IResponse=} [properties] Properties to set 1149 */ 1150 function Response(properties) { 1151 if (properties) 1152 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 1153 if (properties[keys[i]] != null) 1154 this[keys[i]] = properties[keys[i]]; 1155 } 1156 1157 /** 1158 * Response outgoingMessages. 1159 * @member {OutgoingMessagesResponse|null|undefined} outgoingMessages 1160 * @memberof Response 1161 * @instance 1162 */ 1163 Response.prototype.outgoingMessages = null; 1164 1165 /** 1166 * Response channelStats. 1167 * @member {ChannelStatsResponse|null|undefined} channelStats 1168 * @memberof Response 1169 * @instance 1170 */ 1171 Response.prototype.channelStats = null; 1172 1173 /** 1174 * Response serverStats. 1175 * @member {JsonResponse|null|undefined} serverStats 1176 * @memberof Response 1177 * @instance 1178 */ 1179 Response.prototype.serverStats = null; 1180 1181 // OneOf field names bound to virtual getters and setters 1182 var $oneOfFields; 1183 1184 /** 1185 * Response command. 1186 * @member {"outgoingMessages"|"channelStats"|"serverStats"|undefined} command 1187 * @memberof Response 1188 * @instance 1189 */ 1190 Object.defineProperty(Response.prototype, "command", { 1191 get: $util.oneOfGetter($oneOfFields = ["outgoingMessages", "channelStats", "serverStats"]), 1192 set: $util.oneOfSetter($oneOfFields) 1193 }); 1194 1195 /** 1196 * Creates a new Response instance using the specified properties. 1197 * @function create 1198 * @memberof Response 1199 * @static 1200 * @param {IResponse=} [properties] Properties to set 1201 * @returns {Response} Response instance 1202 */ 1203 Response.create = function create(properties) { 1204 return new Response(properties); 1205 }; 1206 1207 /** 1208 * Encodes the specified Response message. Does not implicitly {@link Response.verify|verify} messages. 1209 * @function encode 1210 * @memberof Response 1211 * @static 1212 * @param {Response} message Response message or plain object to encode 1213 * @param {$protobuf.Writer} [writer] Writer to encode to 1214 * @returns {$protobuf.Writer} Writer 1215 */ 1216 Response.encode = function encode(message, writer) { 1217 if (!writer) 1218 writer = $Writer.create(); 1219 if (message.outgoingMessages != null && message.hasOwnProperty("outgoingMessages")) 1220 $root.OutgoingMessagesResponse.encode(message.outgoingMessages, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); 1221 if (message.channelStats != null && message.hasOwnProperty("channelStats")) 1222 $root.ChannelStatsResponse.encode(message.channelStats, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); 1223 if (message.serverStats != null && message.hasOwnProperty("serverStats")) 1224 $root.JsonResponse.encode(message.serverStats, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); 1225 return writer; 1226 }; 1227 1228 /** 1229 * Decodes a Response message from the specified reader or buffer. 1230 * @function decode 1231 * @memberof Response 1232 * @static 1233 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 1234 * @param {number} [length] Message length if known beforehand 1235 * @returns {Response} Response 1236 * @throws {Error} If the payload is not a reader or valid buffer 1237 * @throws {$protobuf.util.ProtocolError} If required fields are missing 1238 */ 1239 Response.decode = function decode(reader, length) { 1240 if (!(reader instanceof $Reader)) 1241 reader = $Reader.create(reader); 1242 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.Response(); 1243 while (reader.pos < end) { 1244 var tag = reader.uint32(); 1245 switch (tag >>> 3) { 1246 case 1: 1247 message.outgoingMessages = $root.OutgoingMessagesResponse.decode(reader, reader.uint32()); 1248 break; 1249 case 2: 1250 message.channelStats = $root.ChannelStatsResponse.decode(reader, reader.uint32()); 1251 break; 1252 case 3: 1253 message.serverStats = $root.JsonResponse.decode(reader, reader.uint32()); 1254 break; 1255 default: 1256 reader.skipType(tag & 7); 1257 break; 1258 } 1259 } 1260 return message; 1261 }; 1262 1263 return Response; 1264 })(); 1265 1266 $root.OutgoingMessagesResponse = (function() { 1267 1268 /** 1269 * Properties of an OutgoingMessagesResponse. 1270 * @exports IOutgoingMessagesResponse 1271 * @interface IOutgoingMessagesResponse 1272 * @property {Array.<OutgoingMessage>|null} [messages] OutgoingMessagesResponse messages 1273 */ 1274 1275 /** 1276 * Constructs a new OutgoingMessagesResponse. 1277 * @exports OutgoingMessagesResponse 1278 * @classdesc Represents an OutgoingMessagesResponse. 1279 * @implements IOutgoingMessagesResponse 1280 * @constructor 1281 * @param {IOutgoingMessagesResponse=} [properties] Properties to set 1282 */ 1283 function OutgoingMessagesResponse(properties) { 1284 this.messages = []; 1285 if (properties) 1286 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 1287 if (properties[keys[i]] != null) 1288 this[keys[i]] = properties[keys[i]]; 1289 } 1290 1291 /** 1292 * OutgoingMessagesResponse messages. 1293 * @member {Array.<OutgoingMessage>} messages 1294 * @memberof OutgoingMessagesResponse 1295 * @instance 1296 */ 1297 OutgoingMessagesResponse.prototype.messages = $util.emptyArray; 1298 1299 /** 1300 * Creates a new OutgoingMessagesResponse instance using the specified properties. 1301 * @function create 1302 * @memberof OutgoingMessagesResponse 1303 * @static 1304 * @param {IOutgoingMessagesResponse=} [properties] Properties to set 1305 * @returns {OutgoingMessagesResponse} OutgoingMessagesResponse instance 1306 */ 1307 OutgoingMessagesResponse.create = function create(properties) { 1308 return new OutgoingMessagesResponse(properties); 1309 }; 1310 1311 /** 1312 * Encodes the specified OutgoingMessagesResponse message. Does not implicitly {@link OutgoingMessagesResponse.verify|verify} messages. 1313 * @function encode 1314 * @memberof OutgoingMessagesResponse 1315 * @static 1316 * @param {OutgoingMessagesResponse} message OutgoingMessagesResponse message or plain object to encode 1317 * @param {$protobuf.Writer} [writer] Writer to encode to 1318 * @returns {$protobuf.Writer} Writer 1319 */ 1320 OutgoingMessagesResponse.encode = function encode(message, writer) { 1321 if (!writer) 1322 writer = $Writer.create(); 1323 if (message.messages != null && message.messages.length) 1324 for (var i = 0; i < message.messages.length; ++i) 1325 $root.OutgoingMessage.encode(message.messages[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); 1326 return writer; 1327 }; 1328 1329 /** 1330 * Decodes an OutgoingMessagesResponse message from the specified reader or buffer. 1331 * @function decode 1332 * @memberof OutgoingMessagesResponse 1333 * @static 1334 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 1335 * @param {number} [length] Message length if known beforehand 1336 * @returns {OutgoingMessagesResponse} OutgoingMessagesResponse 1337 * @throws {Error} If the payload is not a reader or valid buffer 1338 * @throws {$protobuf.util.ProtocolError} If required fields are missing 1339 */ 1340 OutgoingMessagesResponse.decode = function decode(reader, length) { 1341 if (!(reader instanceof $Reader)) 1342 reader = $Reader.create(reader); 1343 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OutgoingMessagesResponse(); 1344 while (reader.pos < end) { 1345 var tag = reader.uint32(); 1346 switch (tag >>> 3) { 1347 case 1: 1348 if (!(message.messages && message.messages.length)) 1349 message.messages = []; 1350 message.messages.push($root.OutgoingMessage.decode(reader, reader.uint32())); 1351 break; 1352 default: 1353 reader.skipType(tag & 7); 1354 break; 1355 } 1356 } 1357 retu
1357rn message; 1358 }; 1359 1360 return OutgoingMessagesResponse; 1361 })(); 1362 1363 $root.OutgoingMessage = (function() { 1364 1365 /** 1366 * Properties of an OutgoingMessage. 1367 * @exports IOutgoingMessage 1368 * @interface IOutgoingMessage 1369 * @property {Uint8Array|null} [id] OutgoingMessage id 1370 * @property {string|null} [body] OutgoingMessage body 1371 * @property {number|null} [expiry] OutgoingMessage expiry 1372 * @property {number|null} [created] OutgoingMessage created 1373 * @property {Sender|null} [sender] OutgoingMessage sender 1374 */ 1375 1376 /** 1377 * Constructs a new OutgoingMessage. 1378 * @exports OutgoingMessage 1379 * @classdesc Represents an OutgoingMessage. 1380 * @implements IOutgoingMessage 1381 * @constructor 1382 * @param {IOutgoingMessage=} [properties] Properties to set 1383 */ 1384 function OutgoingMessage(properties) { 1385 if (properties) 1386 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 1387 if (properties[keys[i]] != null) 1388 this[keys[i]] = properties[keys[i]]; 1389 } 1390 1391 /** 1392 * OutgoingMessage id. 1393 * @member {Uint8Array} id 1394 * @memberof OutgoingMessage 1395 * @instance 1396 */ 1397 OutgoingMessage.prototype.id = $util.newBuffer([]); 1398 1399 /** 1400 * OutgoingMessage body. 1401 * @member {string} body 1402 * @memberof OutgoingMessage 1403 * @instance 1404 */ 1405 OutgoingMessage.prototype.body = ""; 1406 1407 /** 1408 * OutgoingMessage expiry. 1409 * @member {number} expiry 1410 * @memberof OutgoingMessage 1411 * @instance 1412 */ 1413 OutgoingMessage.prototype.expiry = 0; 1414 1415 /** 1416 * OutgoingMessage created. 1417 * @member {number} created 1418 * @memberof OutgoingMessage 1419 * @instance 1420 */ 1421 OutgoingMessage.prototype.created = 0; 1422 1423 /** 1424 * OutgoingMessage sender. 1425 * @member {Sender|null|undefined} sender 1426 * @memberof OutgoingMessage 1427 * @instance 1428 */ 1429 OutgoingMessage.prototype.sender = null; 1430 1431 /** 1432 * Creates a new OutgoingMessage instance using the specified properties. 1433 * @function create 1434 * @memberof OutgoingMessage 1435 * @static 1436 * @param {IOutgoingMessage=} [properties] Properties to set 1437 * @returns {OutgoingMessage} OutgoingMessage instance 1438 */ 1439 OutgoingMessage.create = function create(properties) { 1440 return new OutgoingMessage(properties); 1441 }; 1442 1443 /** 1444 * Encodes the specified OutgoingMessage message. Does not implicitly {@link OutgoingMessage.verify|verify} messages. 1445 * @function encode 1446 * @memberof OutgoingMessage 1447 * @static 1448 * @param {OutgoingMessage} message OutgoingMessage message or plain object to encode 1449 * @param {$protobuf.Writer} [writer] Writer to encode to 1450 * @returns {$protobuf.Writer} Writer 1451 */ 1452 OutgoingMessage.encode = function encode(message, writer) { 1453 if (!writer) 1454 writer = $Writer.create(); 1455 if (message.id != null && message.hasOwnProperty("id")) 1456 writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.id); 1457 if (message.body != null && message.hasOwnProperty("body")) 1458 writer.uint32(/* id 2, wireType 2 =*/18).string(message.body); 1459 if (message.expiry != null && message.hasOwnProperty("expiry")) 1460 writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.expiry); 1461 if (message.created != null && message.hasOwnProperty("created")) 1462 writer.uint32(/* id 4, wireType 5 =*/37).fixed32(message.created); 1463 if (message.sender != null && message.hasOwnProperty("sender")) 1464 $root.Sender.encode(message.sender, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); 1465 return writer; 1466 }; 1467 1468 /** 1469 * Decodes an OutgoingMessage message from the specified reader or buffer. 1470 * @function decode 1471 * @memberof OutgoingMessage 1472 * @static 1473 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 1474 * @param {number} [length] Message length if known beforehand 1475 * @returns {OutgoingMessage} OutgoingMessage 1476 * @throws {Error} If the payload is not a reader or valid buffer 1477 * @throws {$protobuf.util.ProtocolError} If required fields are missing 1478 */ 1479 OutgoingMessage.decode = function decode(reader, length) { 1480 if (!(reader instanceof $Reader)) 1481 reader = $Reader.create(reader); 1482 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OutgoingMessage(); 1483 while (reader.pos < end) { 1484 var tag = reader.uint32(); 1485 switch (tag >>> 3) { 1486 case 1: 1487 message.id = reader.bytes(); 1488 break; 1489 case 2: 1490 message.body = reader.string(); 1491 break; 1492 case 3: 1493 message.expiry = reader.uint32(); 1494 break; 1495 case 4: 1496 message.created = reader.fixed32(); 1497 break; 1498 case 5: 1499 message.sender = $root.Sender.decode(reader, reader.uint32()); 1500 break; 1501 default: 1502 reader.skipType(tag & 7); 1503 break; 1504 } 1505 } 1506 return message; 1507 }; 1508 1509 return OutgoingMessage; 1510 })(); 1511 1512 $root.ChannelStatsResponse = (function() { 1513 1514 /** 1515 * Properties of a ChannelStatsResponse.
1516 * @exports IChannelStatsResponse 1517 * @interface IChannelStatsResponse 1518 * @property {Array.<ChannelStats>|null} [channels] ChannelStatsResponse channels 1519 */ 1520 1521 /** 1522 * Constructs a new ChannelStatsResponse. 1523 * @exports ChannelStatsResponse 1524 * @classdesc Represents a ChannelStatsResponse. 1525 * @implements IChannelStatsResponse 1526 * @constructor 1527 * @param {IChannelStatsResponse=} [properties] Properties to set 1528 */ 1529 function ChannelStatsResponse(properties) { 1530 this.channels = []; 1531 if (properties) 1532 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 1533 if (properties[keys[i]] != null) 1534 this[keys[i]] = properties[keys[i]]; 1535 } 1536 1537 /** 1538 * ChannelStatsResponse channels. 1539 * @member {Array.<ChannelStats>} channels 1540 * @memberof ChannelStatsResponse 1541 * @instance 1542 */ 1543 ChannelStatsResponse.prototype.channels = $util.emptyArray; 1544 1545 /** 1546 * Creates a new ChannelStatsResponse instance using the specified properties. 1547 * @function create 1548 * @memberof ChannelStatsResponse 1549 * @static 1550 * @param {IChannelStatsResponse=} [properties] Properties to set 1551 * @returns {ChannelStatsResponse} ChannelStatsResponse instance 1552 */ 1553 ChannelStatsResponse.create = function create(properties) { 1554 return new ChannelStatsResponse(properties); 1555 }; 1556 1557 /** 1558 * Encodes the specified ChannelStatsResponse message. Does not implicitly {@link ChannelStatsResponse.verify|verify} messages. 1559 * @function encode 1560 * @memberof ChannelStatsResponse 1561 * @static 1562 * @param {ChannelStatsResponse} message ChannelStatsResponse message or plain object to encode 1563 * @param {$protobuf.Writer} [writer] Writer to encode to 1564 * @returns {$protobuf.Writer} Writer 1565 */ 1566 ChannelStatsResponse.encode = function encode(message, writer) { 1567 if (!writer) 1568 writer = $Writer.create(); 1569 if (message.channels != null && message.channels.length) 1570 for (var i = 0; i < message.channels.length; ++i) 1571 $root.ChannelStats.encode(message.channels[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); 1572 return writer; 1573 }; 1574 1575 /** 1576 * Decodes a ChannelStatsResponse message from the specified reader or buffer. 1577 * @function decode 1578 * @memberof ChannelStatsResponse 1579 * @static 1580 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 1581 * @param {number} [length] Message length if known beforehand 1582 * @returns {ChannelStatsResponse} ChannelStatsResponse 1583 * @throws {Error} If the payload is not a reader or valid buffer 1584 * @throws {$protobuf.util.ProtocolError} If required fields are missing 1585 */ 1586 ChannelStatsResponse.decode = function decode(reader, length) { 1587 if (!(reader instanceof $Reader)) 1588 reader = $Reader.create(reader); 1589 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelStatsResponse(); 1590 while (reader.pos < end) { 1591 var tag = reader.uint32(); 1592 switch (tag >>> 3) { 1593 case 1: 1594 if (!(message.channels && message.channels.length)) 1595 message.channels = []; 1596 message.channels.push($root.ChannelStats.decode(reader, reader.uint32())); 1597 break; 1598 default: 1599 reader.skipType(tag & 7); 1600 break; 1601 } 1602 } 1603 return message; 1604 }; 1605 1606 return ChannelStatsResponse; 1607 })(); 1608 1609 $root.ChannelStats = (function() { 1610 1611 /** 1612 * Properties of a ChannelStats. 1613 * @exports IChannelStats 1614 * @interface IChannelStats 1615 * @property {Uint8Array|null} [id] ChannelStats id 1616 * @property {boolean|null} [isPrivate] ChannelStats isPrivate 1617 * @property {boolean|null} [isOnline] ChannelStats isOnline 1618 */ 1619 1620 /** 1621 * Constructs a new ChannelStats. 1622 * @exports ChannelStats 1623 * @classdesc Represents a ChannelStats. 1624 * @implements IChannelStats 1625 * @constructor 1626 * @param {IChannelStats=} [properties] Properties to set 1627 */ 1628 function ChannelStats(properties) { 1629 if (properties) 1630 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 1631 if (properties[keys[i]] != null) 1632 this[keys[i]] = properties[keys[i]]; 1633 } 1634 1635 /** 1636 * ChannelStats id. 1637 * @member {Uint8Array} id 1638 * @memberof ChannelStats 1639 * @instance 1640 */ 1641 ChannelStats.prototype.id = $util.newBuffer([]); 1642 1643 /** 1644 * ChannelStats isPrivate. 1645 * @member {boolean} isPrivate 1646 * @memberof ChannelStats 1647 * @instance 1648 */ 1649 ChannelStats.prototype.isPrivate = false;
1650 1651 /** 1652 * ChannelStats isOnline. 1653 * @member {boolean} isOnline 1654 * @memberof ChannelStats 1655 * @instance 1656 */ 1657 ChannelStats.prototype.isOnline = false; 1658 1659 /** 1660 * Creates a new ChannelStats instance using the specified properties. 1661 * @function create 1662 * @memberof ChannelStats 1663 * @static 1664 * @param {IChannelStats=} [properties] Properties to set 1665 * @returns {ChannelStats} ChannelStats instance 1666 */ 1667 ChannelStats.create = function create(properties) { 1668 return new ChannelStats(properties); 1669 }; 1670 1671 /** 1672 * Encodes the specified ChannelStats message. Does not implicitly {@link ChannelStats.verify|verify} messages. 1673 * @function encode 1674 * @memberof ChannelStats 1675 * @static 1676 * @param {ChannelStats} message ChannelStats message or plain object to encode 1677 * @param {$protobuf.Writer} [writer] Writer to encode to 1678 * @returns {$protobuf.Writer} Writer 1679 */ 1680 ChannelStats.encode = function encode(message, writer) { 1681 if (!writer) 1682 writer = $Writer.create(); 1683 if (message.id != null && message.hasOwnProperty("id")) 1684 writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.id); 1685 if (message.isPrivate != null && message.hasOwnProperty("isPrivate")) 1686 writer.uint32(/* id 2, wireType 0 =*/16).bool(message.isPrivate); 1687 if (message.isOnline != null && message.hasOwnProperty("isOnline")) 1688 writer.uint32(/* id 3, wireType 0 =*/24).bool(message.isOnline); 1689 return writer; 1690 }; 1691 1692 /** 1693 * Decodes a ChannelStats message from the specified reader or buffer. 1694 * @function decode 1695 * @memberof ChannelStats 1696 * @static 1697 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 1698 * @param {number} [length] Message length if known beforehand 1699 * @returns {ChannelStats} ChannelStats 1700 * @throws {Error} If the payload is not a reader or valid buffer 1701 * @throws {$protobuf.util.ProtocolError} If required fields are missing 1702 */ 1703 ChannelStats.decode = function decode(reader, length) { 1704 if (!(reader instanceof $Reader)) 1705 reader = $Reader.create(reader); 1706 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChannelStats(); 1707 while (reader.pos < end) { 1708 var tag = reader.uint32(); 1709 switch (tag >>> 3) { 1710 case 1: 1711 message.id = reader.bytes(); 1712 break; 1713 case 2: 1714 message.isPrivate = reader.bool(); 1715 break; 1716 case 3: 1717 message.isOnline = reader.bool(); 1718 break; 1719 default: 1720 reader.skipType(tag & 7); 1721 break; 1722 } 1723 } 1724 return message; 1725 }; 1726 1727 return ChannelStats; 1728 })(); 1729 1730 $root.JsonResponse = (function() { 1731 1732 /** 1733 * Properties of a JsonResponse. 1734 * @exports IJsonResponse 1735 * @interface IJsonResponse 1736 * @property {string|null} [json] JsonResponse json 1737 */ 1738 1739 /** 1740 * Constructs a new JsonResponse. 1741 * @exports JsonResponse 1742 * @classdesc Represents a JsonResponse. 1743 * @implements IJsonResponse 1744 * @constructor 1745 * @param {IJsonResponse=} [properties] Properties to set 1746 */ 1747 function JsonResponse(properties) { 1748 if (properties) 1749 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) 1750 if (properties[keys[i]] != null) 1751 this[keys[i]] = properties[keys[i]]; 1752 } 1753 1754 /** 1755 * JsonResponse json. 1756 * @member {string} json 1757 * @memberof JsonResponse 1758 * @instance 1759 */ 1760 JsonResponse.prototype.json = ""; 1761 1762 /** 1763 * Creates a new JsonResponse instance using the specified properties. 1764 * @function create 1765 * @memberof JsonResponse 1766 * @static 1767 * @param {IJsonResponse=} [properties] Properties to set 1768 * @returns {JsonResponse} JsonResponse instance 1769 */ 1770 JsonResponse.create = function create(properties) { 1771 return new JsonResponse(properties); 1772 }; 1773 1774 /** 1775 * Encodes the specified JsonResponse message. Does not implicitly {@link JsonResponse.verify|verify} messages. 1776 * @function encode 1777 * @memberof JsonResponse 1778 * @static 1779 * @param {JsonResponse} message JsonResponse message or plain object to encode 1780 * @param {$protobuf.Writer} [writer] Writer to encode to 1781 * @returns {$protobuf.Writer} Writer 1782 */ 1783 JsonResponse.encode = function encode(message, writer) { 1784 if (!writer) 1785 writer = $Writer.create(); 1786 if (message.json != null && message.hasOwnProperty("json")) 1787 writer.uint32(/* id 1, wireType 2 =*/10).string(message.json); 1788 return writer; 1789 }; 1790 1791 /** 1792 * Decodes a JsonResponse message from the specified reader or buffer. 1793 * @function decode 1794 * @memberof JsonResponse 1795 * @static 1796 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from 1797 * @param {number} [length] Message length if known beforehand 1798 * @returns {JsonResponse} JsonResponse 1799 * @throws {Error} If the payload is not a reader or valid buffer 1800 * @throws {$protobuf.util.ProtocolError} If required fields are missing 1801 */ 1802 JsonResponse.decode = function decode(reader, length) { 1803 if (!(reader instanceof $Reader)) 1804 reader = $Reader.create(reader); 1805 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.JsonResponse(); 1806 while (reader.pos < end) { 1807 var tag = reader.uint32(); 1808 switch (tag >>> 3) { 1809 case 1: 1810 message.json = reader.string(); 1811 break; 1812 default: 1813 reader.skipType(tag & 7); 1814 break; 1815 } 1816 } 1817 return message; 1818 }; 1819 1820 return JsonResponse; 1821 })(); 1822 1823 return $root; 1824})( 1825 typeof window==="object" && typeof window.protobuf==='object' && window.protobuf 1826 || typeof self==="object" && typeof self.protobuf==='object' && self.protobuf 1827 || typeof protobuf==='object' && protobuf 1828);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.