@onyx-p/imlib-web 1.5.8 → 1.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.umd.js CHANGED
@@ -12355,821 +12355,827 @@
12355
12355
  return minimal;
12356
12356
  }
12357
12357
 
12358
+ var minimalExports = requireMinimal();
12359
+
12358
12360
  /*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
12359
- var rpc_base;
12360
- var hasRequiredRpc_base;
12361
- function requireRpc_base() {
12362
- if (hasRequiredRpc_base) return rpc_base;
12363
- hasRequiredRpc_base = 1;
12364
- var $protobuf = requireMinimal();
12365
12361
 
12366
- // Common aliases
12367
- var $Reader = $protobuf.Reader,
12368
- $Writer = $protobuf.Writer,
12369
- $util = $protobuf.util;
12362
+ // Common aliases
12363
+ const $Reader$2 = minimalExports.Reader,
12364
+ $Writer$2 = minimalExports.Writer,
12365
+ $util$2 = minimalExports.util;
12370
12366
 
12371
- // Exported root namespace
12372
- var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
12373
- $root.NetworkRequest = function () {
12374
- /**
12375
- * Properties of a NetworkRequest.
12376
- * @exports INetworkRequest
12377
- * @interface INetworkRequest
12378
- * @property {number|null} [cmdId] NetworkRequest cmdId
12379
- * @property {Long|null} [messageSeq] NetworkRequest messageSeq
12380
- * @property {Long|null} [deviceId] NetworkRequest deviceId
12381
- * @property {Long|null} [sessionId] NetworkRequest sessionId
12382
- * @property {Long|null} [uid] NetworkRequest uid
12383
- * @property {number|null} [protocolVersion] NetworkRequest protocolVersion
12384
- * @property {string|null} [destId] NetworkRequest destId
12385
- * @property {Uint8Array|null} [body] NetworkRequest body
12386
- * @property {number|null} [deviceType] NetworkRequest deviceType
12387
- */
12367
+ // Exported root namespace
12368
+ const $root$2 = minimalExports.roots["default"] || (minimalExports.roots["default"] = {});
12369
+ const NetworkRequest = $root$2.NetworkRequest = (() => {
12370
+ /**
12371
+ * Properties of a NetworkRequest.
12372
+ * @exports INetworkRequest
12373
+ * @interface INetworkRequest
12374
+ * @property {number|null} [cmdId] NetworkRequest cmdId
12375
+ * @property {Long|null} [messageSeq] NetworkRequest messageSeq
12376
+ * @property {Long|null} [deviceId] NetworkRequest deviceId
12377
+ * @property {Long|null} [sessionId] NetworkRequest sessionId
12378
+ * @property {Long|null} [uid] NetworkRequest uid
12379
+ * @property {number|null} [protocolVersion] NetworkRequest protocolVersion
12380
+ * @property {string|null} [destId] NetworkRequest destId
12381
+ * @property {Uint8Array|null} [body] NetworkRequest body
12382
+ * @property {string|null} [deviceCode] NetworkRequest deviceCode
12383
+ * @property {number|null} [deviceType] NetworkRequest deviceType
12384
+ */
12385
+
12386
+ /**
12387
+ * Constructs a new NetworkRequest.
12388
+ * @exports NetworkRequest
12389
+ * @classdesc Represents a NetworkRequest.
12390
+ * @implements INetworkRequest
12391
+ * @constructor
12392
+ * @param {INetworkRequest=} [properties] Properties to set
12393
+ */
12394
+ function NetworkRequest(properties) {
12395
+ if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12396
+ }
12388
12397
 
12389
- /**
12390
- * Constructs a new NetworkRequest.
12391
- * @exports NetworkRequest
12392
- * @classdesc Represents a NetworkRequest.
12393
- * @implements INetworkRequest
12394
- * @constructor
12395
- * @param {INetworkRequest=} [properties] Properties to set
12396
- */
12397
- function NetworkRequest(properties) {
12398
- if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12399
- }
12398
+ /**
12399
+ * NetworkRequest cmdId.
12400
+ * @member {number} cmdId
12401
+ * @memberof NetworkRequest
12402
+ * @instance
12403
+ */
12404
+ NetworkRequest.prototype.cmdId = 0;
12400
12405
 
12401
- /**
12402
- * NetworkRequest cmdId.
12403
- * @member {number} cmdId
12404
- * @memberof NetworkRequest
12405
- * @instance
12406
- */
12407
- NetworkRequest.prototype.cmdId = 0;
12406
+ /**
12407
+ * NetworkRequest messageSeq.
12408
+ * @member {Long} messageSeq
12409
+ * @memberof NetworkRequest
12410
+ * @instance
12411
+ */
12412
+ NetworkRequest.prototype.messageSeq = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12408
12413
 
12409
- /**
12410
- * NetworkRequest messageSeq.
12411
- * @member {Long} messageSeq
12412
- * @memberof NetworkRequest
12413
- * @instance
12414
- */
12415
- NetworkRequest.prototype.messageSeq = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12414
+ /**
12415
+ * NetworkRequest deviceId.
12416
+ * @member {Long} deviceId
12417
+ * @memberof NetworkRequest
12418
+ * @instance
12419
+ */
12420
+ NetworkRequest.prototype.deviceId = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12416
12421
 
12417
- /**
12418
- * NetworkRequest deviceId.
12419
- * @member {Long} deviceId
12420
- * @memberof NetworkRequest
12421
- * @instance
12422
- */
12423
- NetworkRequest.prototype.deviceId = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12422
+ /**
12423
+ * NetworkRequest sessionId.
12424
+ * @member {Long} sessionId
12425
+ * @memberof NetworkRequest
12426
+ * @instance
12427
+ */
12428
+ NetworkRequest.prototype.sessionId = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12424
12429
 
12425
- /**
12426
- * NetworkRequest sessionId.
12427
- * @member {Long} sessionId
12428
- * @memberof NetworkRequest
12429
- * @instance
12430
- */
12431
- NetworkRequest.prototype.sessionId = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12430
+ /**
12431
+ * NetworkRequest uid.
12432
+ * @member {Long} uid
12433
+ * @memberof NetworkRequest
12434
+ * @instance
12435
+ */
12436
+ NetworkRequest.prototype.uid = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12432
12437
 
12433
- /**
12434
- * NetworkRequest uid.
12435
- * @member {Long} uid
12436
- * @memberof NetworkRequest
12437
- * @instance
12438
- */
12439
- NetworkRequest.prototype.uid = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12438
+ /**
12439
+ * NetworkRequest protocolVersion.
12440
+ * @member {number} protocolVersion
12441
+ * @memberof NetworkRequest
12442
+ * @instance
12443
+ */
12444
+ NetworkRequest.prototype.protocolVersion = 0;
12440
12445
 
12441
- /**
12442
- * NetworkRequest protocolVersion.
12443
- * @member {number} protocolVersion
12444
- * @memberof NetworkRequest
12445
- * @instance
12446
- */
12447
- NetworkRequest.prototype.protocolVersion = 0;
12446
+ /**
12447
+ * NetworkRequest destId.
12448
+ * @member {string} destId
12449
+ * @memberof NetworkRequest
12450
+ * @instance
12451
+ */
12452
+ NetworkRequest.prototype.destId = "";
12448
12453
 
12449
- /**
12450
- * NetworkRequest destId.
12451
- * @member {string} destId
12452
- * @memberof NetworkRequest
12453
- * @instance
12454
- */
12455
- NetworkRequest.prototype.destId = "";
12454
+ /**
12455
+ * NetworkRequest body.
12456
+ * @member {Uint8Array} body
12457
+ * @memberof NetworkRequest
12458
+ * @instance
12459
+ */
12460
+ NetworkRequest.prototype.body = $util$2.newBuffer([]);
12456
12461
 
12457
- /**
12458
- * NetworkRequest body.
12459
- * @member {Uint8Array} body
12460
- * @memberof NetworkRequest
12461
- * @instance
12462
- */
12463
- NetworkRequest.prototype.body = $util.newBuffer([]);
12462
+ /**
12463
+ * NetworkRequest deviceCode.
12464
+ * @member {string} deviceCode
12465
+ * @memberof NetworkRequest
12466
+ * @instance
12467
+ */
12468
+ NetworkRequest.prototype.deviceCode = "";
12464
12469
 
12465
- /**
12466
- * NetworkRequest deviceType.
12467
- * @member {number} deviceType
12468
- * @memberof NetworkRequest
12469
- * @instance
12470
- */
12471
- NetworkRequest.prototype.deviceType = 0;
12470
+ /**
12471
+ * NetworkRequest deviceType.
12472
+ * @member {number} deviceType
12473
+ * @memberof NetworkRequest
12474
+ * @instance
12475
+ */
12476
+ NetworkRequest.prototype.deviceType = 0;
12472
12477
 
12473
- /**
12474
- * Encodes the specified NetworkRequest message. Does not implicitly {@link NetworkRequest.verify|verify} messages.
12475
- * @function encode
12476
- * @memberof NetworkRequest
12477
- * @static
12478
- * @param {INetworkRequest} message NetworkRequest message or plain object to encode
12479
- * @param {$protobuf.Writer} [writer] Writer to encode to
12480
- * @returns {$protobuf.Writer} Writer
12481
- */
12482
- NetworkRequest.encode = function encode(message, writer) {
12483
- if (!writer) writer = $Writer.create();
12484
- if (message.cmdId != null && Object.hasOwnProperty.call(message, "cmdId")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.cmdId);
12485
- if (message.messageSeq != null && Object.hasOwnProperty.call(message, "messageSeq")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.messageSeq);
12486
- if (message.deviceId != null && Object.hasOwnProperty.call(message, "deviceId")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.deviceId);
12487
- if (message.sessionId != null && Object.hasOwnProperty.call(message, "sessionId")) writer.uint32(/* id 4, wireType 0 =*/32).int64(message.sessionId);
12488
- if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) writer.uint32(/* id 5, wireType 0 =*/40).int64(message.uid);
12489
- if (message.protocolVersion != null && Object.hasOwnProperty.call(message, "protocolVersion")) writer.uint32(/* id 6, wireType 0 =*/48).int32(message.protocolVersion);
12490
- if (message.destId != null && Object.hasOwnProperty.call(message, "destId")) writer.uint32(/* id 7, wireType 2 =*/58).string(message.destId);
12491
- if (message.body != null && Object.hasOwnProperty.call(message, "body")) writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.body);
12492
- if (message.deviceType != null && Object.hasOwnProperty.call(message, "deviceType")) writer.uint32(/* id 12, wireType 0 =*/96).int32(message.deviceType);
12493
- return writer;
12494
- };
12478
+ /**
12479
+ * Encodes the specified NetworkRequest message. Does not implicitly {@link NetworkRequest.verify|verify} messages.
12480
+ * @function encode
12481
+ * @memberof NetworkRequest
12482
+ * @static
12483
+ * @param {INetworkRequest} message NetworkRequest message or plain object to encode
12484
+ * @param {$protobuf.Writer} [writer] Writer to encode to
12485
+ * @returns {$protobuf.Writer} Writer
12486
+ */
12487
+ NetworkRequest.encode = function encode(message, writer) {
12488
+ if (!writer) writer = $Writer$2.create();
12489
+ if (message.cmdId != null && Object.hasOwnProperty.call(message, "cmdId")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.cmdId);
12490
+ if (message.messageSeq != null && Object.hasOwnProperty.call(message, "messageSeq")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.messageSeq);
12491
+ if (message.deviceId != null && Object.hasOwnProperty.call(message, "deviceId")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.deviceId);
12492
+ if (message.sessionId != null && Object.hasOwnProperty.call(message, "sessionId")) writer.uint32(/* id 4, wireType 0 =*/32).int64(message.sessionId);
12493
+ if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) writer.uint32(/* id 5, wireType 0 =*/40).int64(message.uid);
12494
+ if (message.protocolVersion != null && Object.hasOwnProperty.call(message, "protocolVersion")) writer.uint32(/* id 6, wireType 0 =*/48).int32(message.protocolVersion);
12495
+ if (message.destId != null && Object.hasOwnProperty.call(message, "destId")) writer.uint32(/* id 7, wireType 2 =*/58).string(message.destId);
12496
+ if (message.body != null && Object.hasOwnProperty.call(message, "body")) writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.body);
12497
+ if (message.deviceCode != null && Object.hasOwnProperty.call(message, "deviceCode")) writer.uint32(/* id 9, wireType 2 =*/74).string(message.deviceCode);
12498
+ if (message.deviceType != null && Object.hasOwnProperty.call(message, "deviceType")) writer.uint32(/* id 12, wireType 0 =*/96).int32(message.deviceType);
12499
+ return writer;
12500
+ };
12495
12501
 
12496
- /**
12497
- * Decodes a NetworkRequest message from the specified reader or buffer.
12498
- * @function decode
12499
- * @memberof NetworkRequest
12500
- * @static
12501
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12502
- * @param {number} [length] Message length if known beforehand
12503
- * @returns {NetworkRequest} NetworkRequest
12504
- * @throws {Error} If the payload is not a reader or valid buffer
12505
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
12506
- */
12507
- NetworkRequest.decode = function decode(reader, length) {
12508
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
12509
- var end = length === undefined ? reader.len : reader.pos + length,
12510
- message = new $root.NetworkRequest();
12511
- while (reader.pos < end) {
12512
- var tag = reader.uint32();
12513
- switch (tag >>> 3) {
12514
- case 1:
12515
- {
12516
- message.cmdId = reader.int32();
12517
- break;
12518
- }
12519
- case 2:
12520
- {
12521
- message.messageSeq = reader.int64();
12522
- break;
12523
- }
12524
- case 3:
12525
- {
12526
- message.deviceId = reader.int64();
12527
- break;
12528
- }
12529
- case 4:
12530
- {
12531
- message.sessionId = reader.int64();
12532
- break;
12533
- }
12534
- case 5:
12535
- {
12536
- message.uid = reader.int64();
12537
- break;
12538
- }
12539
- case 6:
12540
- {
12541
- message.protocolVersion = reader.int32();
12542
- break;
12543
- }
12544
- case 7:
12545
- {
12546
- message.destId = reader.string();
12547
- break;
12548
- }
12549
- case 8:
12550
- {
12551
- message.body = reader.bytes();
12552
- break;
12553
- }
12554
- case 12:
12555
- {
12556
- message.deviceType = reader.int32();
12557
- break;
12558
- }
12559
- default:
12560
- reader.skipType(tag & 7);
12502
+ /**
12503
+ * Decodes a NetworkRequest message from the specified reader or buffer.
12504
+ * @function decode
12505
+ * @memberof NetworkRequest
12506
+ * @static
12507
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12508
+ * @param {number} [length] Message length if known beforehand
12509
+ * @returns {NetworkRequest} NetworkRequest
12510
+ * @throws {Error} If the payload is not a reader or valid buffer
12511
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
12512
+ */
12513
+ NetworkRequest.decode = function decode(reader, length) {
12514
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
12515
+ let end = length === undefined ? reader.len : reader.pos + length,
12516
+ message = new $root$2.NetworkRequest();
12517
+ while (reader.pos < end) {
12518
+ let tag = reader.uint32();
12519
+ switch (tag >>> 3) {
12520
+ case 1:
12521
+ {
12522
+ message.cmdId = reader.int32();
12561
12523
  break;
12562
- }
12563
- }
12564
- return message;
12565
- };
12566
-
12567
- /**
12568
- * Gets the default type url for NetworkRequest
12569
- * @function getTypeUrl
12570
- * @memberof NetworkRequest
12571
- * @static
12572
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12573
- * @returns {string} The default type url
12574
- */
12575
- NetworkRequest.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12576
- if (typeUrlPrefix === undefined) {
12577
- typeUrlPrefix = "type.googleapis.com";
12524
+ }
12525
+ case 2:
12526
+ {
12527
+ message.messageSeq = reader.int64();
12528
+ break;
12529
+ }
12530
+ case 3:
12531
+ {
12532
+ message.deviceId = reader.int64();
12533
+ break;
12534
+ }
12535
+ case 4:
12536
+ {
12537
+ message.sessionId = reader.int64();
12538
+ break;
12539
+ }
12540
+ case 5:
12541
+ {
12542
+ message.uid = reader.int64();
12543
+ break;
12544
+ }
12545
+ case 6:
12546
+ {
12547
+ message.protocolVersion = reader.int32();
12548
+ break;
12549
+ }
12550
+ case 7:
12551
+ {
12552
+ message.destId = reader.string();
12553
+ break;
12554
+ }
12555
+ case 8:
12556
+ {
12557
+ message.body = reader.bytes();
12558
+ break;
12559
+ }
12560
+ case 9:
12561
+ {
12562
+ message.deviceCode = reader.string();
12563
+ break;
12564
+ }
12565
+ case 12:
12566
+ {
12567
+ message.deviceType = reader.int32();
12568
+ break;
12569
+ }
12570
+ default:
12571
+ reader.skipType(tag & 7);
12572
+ break;
12578
12573
  }
12579
- return typeUrlPrefix + "/NetworkRequest";
12580
- };
12581
- return NetworkRequest;
12582
- }();
12583
- $root.NetworkResponse = function () {
12584
- /**
12585
- * Properties of a NetworkResponse.
12586
- * @exports INetworkResponse
12587
- * @interface INetworkResponse
12588
- * @property {number|null} [cmdId] NetworkResponse cmdId
12589
- * @property {Long|null} [messageSeq] NetworkResponse messageSeq
12590
- * @property {Long|null} [deviceId] NetworkResponse deviceId
12591
- * @property {Long|null} [uid] NetworkResponse uid
12592
- * @property {number|null} [protocolVersion] NetworkResponse protocolVersion
12593
- * @property {Uint8Array|null} [body] NetworkResponse body
12594
- * @property {number|null} [code] NetworkResponse code
12595
- */
12574
+ }
12575
+ return message;
12576
+ };
12596
12577
 
12597
- /**
12598
- * Constructs a new NetworkResponse.
12599
- * @exports NetworkResponse
12600
- * @classdesc Represents a NetworkResponse.
12601
- * @implements INetworkResponse
12602
- * @constructor
12603
- * @param {INetworkResponse=} [properties] Properties to set
12604
- */
12605
- function NetworkResponse(properties) {
12606
- if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12578
+ /**
12579
+ * Gets the default type url for NetworkRequest
12580
+ * @function getTypeUrl
12581
+ * @memberof NetworkRequest
12582
+ * @static
12583
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12584
+ * @returns {string} The default type url
12585
+ */
12586
+ NetworkRequest.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12587
+ if (typeUrlPrefix === undefined) {
12588
+ typeUrlPrefix = "type.googleapis.com";
12607
12589
  }
12590
+ return typeUrlPrefix + "/NetworkRequest";
12591
+ };
12592
+ return NetworkRequest;
12593
+ })();
12594
+ const NetworkResponse = $root$2.NetworkResponse = (() => {
12595
+ /**
12596
+ * Properties of a NetworkResponse.
12597
+ * @exports INetworkResponse
12598
+ * @interface INetworkResponse
12599
+ * @property {number|null} [cmdId] NetworkResponse cmdId
12600
+ * @property {Long|null} [messageSeq] NetworkResponse messageSeq
12601
+ * @property {Long|null} [deviceId] NetworkResponse deviceId
12602
+ * @property {Long|null} [uid] NetworkResponse uid
12603
+ * @property {number|null} [protocolVersion] NetworkResponse protocolVersion
12604
+ * @property {Uint8Array|null} [body] NetworkResponse body
12605
+ * @property {number|null} [code] NetworkResponse code
12606
+ */
12608
12607
 
12609
- /**
12610
- * NetworkResponse cmdId.
12611
- * @member {number} cmdId
12612
- * @memberof NetworkResponse
12613
- * @instance
12614
- */
12615
- NetworkResponse.prototype.cmdId = 0;
12608
+ /**
12609
+ * Constructs a new NetworkResponse.
12610
+ * @exports NetworkResponse
12611
+ * @classdesc Represents a NetworkResponse.
12612
+ * @implements INetworkResponse
12613
+ * @constructor
12614
+ * @param {INetworkResponse=} [properties] Properties to set
12615
+ */
12616
+ function NetworkResponse(properties) {
12617
+ if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12618
+ }
12616
12619
 
12617
- /**
12618
- * NetworkResponse messageSeq.
12619
- * @member {Long} messageSeq
12620
- * @memberof NetworkResponse
12621
- * @instance
12622
- */
12623
- NetworkResponse.prototype.messageSeq = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12620
+ /**
12621
+ * NetworkResponse cmdId.
12622
+ * @member {number} cmdId
12623
+ * @memberof NetworkResponse
12624
+ * @instance
12625
+ */
12626
+ NetworkResponse.prototype.cmdId = 0;
12624
12627
 
12625
- /**
12626
- * NetworkResponse deviceId.
12627
- * @member {Long} deviceId
12628
- * @memberof NetworkResponse
12629
- * @instance
12630
- */
12631
- NetworkResponse.prototype.deviceId = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12628
+ /**
12629
+ * NetworkResponse messageSeq.
12630
+ * @member {Long} messageSeq
12631
+ * @memberof NetworkResponse
12632
+ * @instance
12633
+ */
12634
+ NetworkResponse.prototype.messageSeq = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12632
12635
 
12633
- /**
12634
- * NetworkResponse uid.
12635
- * @member {Long} uid
12636
- * @memberof NetworkResponse
12637
- * @instance
12638
- */
12639
- NetworkResponse.prototype.uid = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12636
+ /**
12637
+ * NetworkResponse deviceId.
12638
+ * @member {Long} deviceId
12639
+ * @memberof NetworkResponse
12640
+ * @instance
12641
+ */
12642
+ NetworkResponse.prototype.deviceId = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12640
12643
 
12641
- /**
12642
- * NetworkResponse protocolVersion.
12643
- * @member {number} protocolVersion
12644
- * @memberof NetworkResponse
12645
- * @instance
12646
- */
12647
- NetworkResponse.prototype.protocolVersion = 0;
12644
+ /**
12645
+ * NetworkResponse uid.
12646
+ * @member {Long} uid
12647
+ * @memberof NetworkResponse
12648
+ * @instance
12649
+ */
12650
+ NetworkResponse.prototype.uid = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12648
12651
 
12649
- /**
12650
- * NetworkResponse body.
12651
- * @member {Uint8Array} body
12652
- * @memberof NetworkResponse
12653
- * @instance
12654
- */
12655
- NetworkResponse.prototype.body = $util.newBuffer([]);
12652
+ /**
12653
+ * NetworkResponse protocolVersion.
12654
+ * @member {number} protocolVersion
12655
+ * @memberof NetworkResponse
12656
+ * @instance
12657
+ */
12658
+ NetworkResponse.prototype.protocolVersion = 0;
12656
12659
 
12657
- /**
12658
- * NetworkResponse code.
12659
- * @member {number} code
12660
- * @memberof NetworkResponse
12661
- * @instance
12662
- */
12663
- NetworkResponse.prototype.code = 0;
12660
+ /**
12661
+ * NetworkResponse body.
12662
+ * @member {Uint8Array} body
12663
+ * @memberof NetworkResponse
12664
+ * @instance
12665
+ */
12666
+ NetworkResponse.prototype.body = $util$2.newBuffer([]);
12664
12667
 
12665
- /**
12666
- * Encodes the specified NetworkResponse message. Does not implicitly {@link NetworkResponse.verify|verify} messages.
12667
- * @function encode
12668
- * @memberof NetworkResponse
12669
- * @static
12670
- * @param {INetworkResponse} message NetworkResponse message or plain object to encode
12671
- * @param {$protobuf.Writer} [writer] Writer to encode to
12672
- * @returns {$protobuf.Writer} Writer
12673
- */
12674
- NetworkResponse.encode = function encode(message, writer) {
12675
- if (!writer) writer = $Writer.create();
12676
- if (message.cmdId != null && Object.hasOwnProperty.call(message, "cmdId")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.cmdId);
12677
- if (message.messageSeq != null && Object.hasOwnProperty.call(message, "messageSeq")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.messageSeq);
12678
- if (message.deviceId != null && Object.hasOwnProperty.call(message, "deviceId")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.deviceId);
12679
- if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) writer.uint32(/* id 5, wireType 0 =*/40).int64(message.uid);
12680
- if (message.protocolVersion != null && Object.hasOwnProperty.call(message, "protocolVersion")) writer.uint32(/* id 6, wireType 0 =*/48).int32(message.protocolVersion);
12681
- if (message.body != null && Object.hasOwnProperty.call(message, "body")) writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.body);
12682
- if (message.code != null && Object.hasOwnProperty.call(message, "code")) writer.uint32(/* id 9, wireType 0 =*/72).int32(message.code);
12683
- return writer;
12684
- };
12668
+ /**
12669
+ * NetworkResponse code.
12670
+ * @member {number} code
12671
+ * @memberof NetworkResponse
12672
+ * @instance
12673
+ */
12674
+ NetworkResponse.prototype.code = 0;
12685
12675
 
12686
- /**
12687
- * Decodes a NetworkResponse message from the specified reader or buffer.
12688
- * @function decode
12689
- * @memberof NetworkResponse
12690
- * @static
12691
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12692
- * @param {number} [length] Message length if known beforehand
12693
- * @returns {NetworkResponse} NetworkResponse
12694
- * @throws {Error} If the payload is not a reader or valid buffer
12695
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
12696
- */
12697
- NetworkResponse.decode = function decode(reader, length) {
12698
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
12699
- var end = length === undefined ? reader.len : reader.pos + length,
12700
- message = new $root.NetworkResponse();
12701
- while (reader.pos < end) {
12702
- var tag = reader.uint32();
12703
- switch (tag >>> 3) {
12704
- case 1:
12705
- {
12706
- message.cmdId = reader.int32();
12707
- break;
12708
- }
12709
- case 2:
12710
- {
12711
- message.messageSeq = reader.int64();
12712
- break;
12713
- }
12714
- case 3:
12715
- {
12716
- message.deviceId = reader.int64();
12717
- break;
12718
- }
12719
- case 5:
12720
- {
12721
- message.uid = reader.int64();
12722
- break;
12723
- }
12724
- case 6:
12725
- {
12726
- message.protocolVersion = reader.int32();
12727
- break;
12728
- }
12729
- case 8:
12730
- {
12731
- message.body = reader.bytes();
12732
- break;
12733
- }
12734
- case 9:
12735
- {
12736
- message.code = reader.int32();
12737
- break;
12738
- }
12739
- default:
12740
- reader.skipType(tag & 7);
12741
- break;
12742
- }
12743
- }
12744
- return message;
12745
- };
12676
+ /**
12677
+ * Encodes the specified NetworkResponse message. Does not implicitly {@link NetworkResponse.verify|verify} messages.
12678
+ * @function encode
12679
+ * @memberof NetworkResponse
12680
+ * @static
12681
+ * @param {INetworkResponse} message NetworkResponse message or plain object to encode
12682
+ * @param {$protobuf.Writer} [writer] Writer to encode to
12683
+ * @returns {$protobuf.Writer} Writer
12684
+ */
12685
+ NetworkResponse.encode = function encode(message, writer) {
12686
+ if (!writer) writer = $Writer$2.create();
12687
+ if (message.cmdId != null && Object.hasOwnProperty.call(message, "cmdId")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.cmdId);
12688
+ if (message.messageSeq != null && Object.hasOwnProperty.call(message, "messageSeq")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.messageSeq);
12689
+ if (message.deviceId != null && Object.hasOwnProperty.call(message, "deviceId")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.deviceId);
12690
+ if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) writer.uint32(/* id 5, wireType 0 =*/40).int64(message.uid);
12691
+ if (message.protocolVersion != null && Object.hasOwnProperty.call(message, "protocolVersion")) writer.uint32(/* id 6, wireType 0 =*/48).int32(message.protocolVersion);
12692
+ if (message.body != null && Object.hasOwnProperty.call(message, "body")) writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.body);
12693
+ if (message.code != null && Object.hasOwnProperty.call(message, "code")) writer.uint32(/* id 9, wireType 0 =*/72).int32(message.code);
12694
+ return writer;
12695
+ };
12746
12696
 
12747
- /**
12748
- * Gets the default type url for NetworkResponse
12749
- * @function getTypeUrl
12750
- * @memberof NetworkResponse
12751
- * @static
12752
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12753
- * @returns {string} The default type url
12754
- */
12755
- NetworkResponse.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12756
- if (typeUrlPrefix === undefined) {
12757
- typeUrlPrefix = "type.googleapis.com";
12697
+ /**
12698
+ * Decodes a NetworkResponse message from the specified reader or buffer.
12699
+ * @function decode
12700
+ * @memberof NetworkResponse
12701
+ * @static
12702
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12703
+ * @param {number} [length] Message length if known beforehand
12704
+ * @returns {NetworkResponse} NetworkResponse
12705
+ * @throws {Error} If the payload is not a reader or valid buffer
12706
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
12707
+ */
12708
+ NetworkResponse.decode = function decode(reader, length) {
12709
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
12710
+ let end = length === undefined ? reader.len : reader.pos + length,
12711
+ message = new $root$2.NetworkResponse();
12712
+ while (reader.pos < end) {
12713
+ let tag = reader.uint32();
12714
+ switch (tag >>> 3) {
12715
+ case 1:
12716
+ {
12717
+ message.cmdId = reader.int32();
12718
+ break;
12719
+ }
12720
+ case 2:
12721
+ {
12722
+ message.messageSeq = reader.int64();
12723
+ break;
12724
+ }
12725
+ case 3:
12726
+ {
12727
+ message.deviceId = reader.int64();
12728
+ break;
12729
+ }
12730
+ case 5:
12731
+ {
12732
+ message.uid = reader.int64();
12733
+ break;
12734
+ }
12735
+ case 6:
12736
+ {
12737
+ message.protocolVersion = reader.int32();
12738
+ break;
12739
+ }
12740
+ case 8:
12741
+ {
12742
+ message.body = reader.bytes();
12743
+ break;
12744
+ }
12745
+ case 9:
12746
+ {
12747
+ message.code = reader.int32();
12748
+ break;
12749
+ }
12750
+ default:
12751
+ reader.skipType(tag & 7);
12752
+ break;
12758
12753
  }
12759
- return typeUrlPrefix + "/NetworkResponse";
12760
- };
12761
- return NetworkResponse;
12762
- }();
12763
- $root.HeartbeatReq = function () {
12764
- /**
12765
- * Properties of a HeartbeatReq.
12766
- * @exports IHeartbeatReq
12767
- * @interface IHeartbeatReq
12768
- * @property {Long|null} [pingId] HeartbeatReq pingId
12769
- * @property {Long|null} [disconnectDelay] HeartbeatReq disconnectDelay
12770
- */
12771
-
12772
- /**
12773
- * Constructs a new HeartbeatReq.
12774
- * @exports HeartbeatReq
12775
- * @classdesc Represents a HeartbeatReq.
12776
- * @implements IHeartbeatReq
12777
- * @constructor
12778
- * @param {IHeartbeatReq=} [properties] Properties to set
12779
- */
12780
- function HeartbeatReq(properties) {
12781
- if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12782
12754
  }
12755
+ return message;
12756
+ };
12783
12757
 
12784
- /**
12785
- * HeartbeatReq pingId.
12786
- * @member {Long} pingId
12787
- * @memberof HeartbeatReq
12788
- * @instance
12789
- */
12790
- HeartbeatReq.prototype.pingId = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12791
-
12792
- /**
12793
- * HeartbeatReq disconnectDelay.
12794
- * @member {Long} disconnectDelay
12795
- * @memberof HeartbeatReq
12796
- * @instance
12797
- */
12798
- HeartbeatReq.prototype.disconnectDelay = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12799
-
12800
- /**
12801
- * Encodes the specified HeartbeatReq message. Does not implicitly {@link HeartbeatReq.verify|verify} messages.
12802
- * @function encode
12803
- * @memberof HeartbeatReq
12804
- * @static
12805
- * @param {IHeartbeatReq} message HeartbeatReq message or plain object to encode
12806
- * @param {$protobuf.Writer} [writer] Writer to encode to
12807
- * @returns {$protobuf.Writer} Writer
12808
- */
12809
- HeartbeatReq.encode = function encode(message, writer) {
12810
- if (!writer) writer = $Writer.create();
12811
- if (message.pingId != null && Object.hasOwnProperty.call(message, "pingId")) writer.uint32(/* id 1, wireType 0 =*/8).int64(message.pingId);
12812
- if (message.disconnectDelay != null && Object.hasOwnProperty.call(message, "disconnectDelay")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.disconnectDelay);
12813
- return writer;
12814
- };
12758
+ /**
12759
+ * Gets the default type url for NetworkResponse
12760
+ * @function getTypeUrl
12761
+ * @memberof NetworkResponse
12762
+ * @static
12763
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12764
+ * @returns {string} The default type url
12765
+ */
12766
+ NetworkResponse.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12767
+ if (typeUrlPrefix === undefined) {
12768
+ typeUrlPrefix = "type.googleapis.com";
12769
+ }
12770
+ return typeUrlPrefix + "/NetworkResponse";
12771
+ };
12772
+ return NetworkResponse;
12773
+ })();
12774
+ const HeartbeatReq = $root$2.HeartbeatReq = (() => {
12775
+ /**
12776
+ * Properties of a HeartbeatReq.
12777
+ * @exports IHeartbeatReq
12778
+ * @interface IHeartbeatReq
12779
+ * @property {Long|null} [pingId] HeartbeatReq pingId
12780
+ * @property {Long|null} [disconnectDelay] HeartbeatReq disconnectDelay
12781
+ */
12815
12782
 
12816
- /**
12817
- * Decodes a HeartbeatReq message from the specified reader or buffer.
12818
- * @function decode
12819
- * @memberof HeartbeatReq
12820
- * @static
12821
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12822
- * @param {number} [length] Message length if known beforehand
12823
- * @returns {HeartbeatReq} HeartbeatReq
12824
- * @throws {Error} If the payload is not a reader or valid buffer
12825
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
12826
- */
12827
- HeartbeatReq.decode = function decode(reader, length) {
12828
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
12829
- var end = length === undefined ? reader.len : reader.pos + length,
12830
- message = new $root.HeartbeatReq();
12831
- while (reader.pos < end) {
12832
- var tag = reader.uint32();
12833
- switch (tag >>> 3) {
12834
- case 1:
12835
- {
12836
- message.pingId = reader.int64();
12837
- break;
12838
- }
12839
- case 2:
12840
- {
12841
- message.disconnectDelay = reader.int64();
12842
- break;
12843
- }
12844
- default:
12845
- reader.skipType(tag & 7);
12846
- break;
12847
- }
12848
- }
12849
- return message;
12850
- };
12783
+ /**
12784
+ * Constructs a new HeartbeatReq.
12785
+ * @exports HeartbeatReq
12786
+ * @classdesc Represents a HeartbeatReq.
12787
+ * @implements IHeartbeatReq
12788
+ * @constructor
12789
+ * @param {IHeartbeatReq=} [properties] Properties to set
12790
+ */
12791
+ function HeartbeatReq(properties) {
12792
+ if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12793
+ }
12851
12794
 
12852
- /**
12853
- * Gets the default type url for HeartbeatReq
12854
- * @function getTypeUrl
12855
- * @memberof HeartbeatReq
12856
- * @static
12857
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12858
- * @returns {string} The default type url
12859
- */
12860
- HeartbeatReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12861
- if (typeUrlPrefix === undefined) {
12862
- typeUrlPrefix = "type.googleapis.com";
12863
- }
12864
- return typeUrlPrefix + "/HeartbeatReq";
12865
- };
12866
- return HeartbeatReq;
12867
- }();
12868
- $root.SystemCurrentTimeMillisReq = function () {
12869
- /**
12870
- * Properties of a SystemCurrentTimeMillisReq.
12871
- * @exports ISystemCurrentTimeMillisReq
12872
- * @interface ISystemCurrentTimeMillisReq
12873
- */
12795
+ /**
12796
+ * HeartbeatReq pingId.
12797
+ * @member {Long} pingId
12798
+ * @memberof HeartbeatReq
12799
+ * @instance
12800
+ */
12801
+ HeartbeatReq.prototype.pingId = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12874
12802
 
12875
- /**
12876
- * Constructs a new SystemCurrentTimeMillisReq.
12877
- * @exports SystemCurrentTimeMillisReq
12878
- * @classdesc Represents a SystemCurrentTimeMillisReq.
12879
- * @implements ISystemCurrentTimeMillisReq
12880
- * @constructor
12881
- * @param {ISystemCurrentTimeMillisReq=} [properties] Properties to set
12882
- */
12883
- function SystemCurrentTimeMillisReq(properties) {
12884
- if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12885
- }
12803
+ /**
12804
+ * HeartbeatReq disconnectDelay.
12805
+ * @member {Long} disconnectDelay
12806
+ * @memberof HeartbeatReq
12807
+ * @instance
12808
+ */
12809
+ HeartbeatReq.prototype.disconnectDelay = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12886
12810
 
12887
- /**
12888
- * Encodes the specified SystemCurrentTimeMillisReq message. Does not implicitly {@link SystemCurrentTimeMillisReq.verify|verify} messages.
12889
- * @function encode
12890
- * @memberof SystemCurrentTimeMillisReq
12891
- * @static
12892
- * @param {ISystemCurrentTimeMillisReq} message SystemCurrentTimeMillisReq message or plain object to encode
12893
- * @param {$protobuf.Writer} [writer] Writer to encode to
12894
- * @returns {$protobuf.Writer} Writer
12895
- */
12896
- SystemCurrentTimeMillisReq.encode = function encode(message, writer) {
12897
- if (!writer) writer = $Writer.create();
12898
- return writer;
12899
- };
12811
+ /**
12812
+ * Encodes the specified HeartbeatReq message. Does not implicitly {@link HeartbeatReq.verify|verify} messages.
12813
+ * @function encode
12814
+ * @memberof HeartbeatReq
12815
+ * @static
12816
+ * @param {IHeartbeatReq} message HeartbeatReq message or plain object to encode
12817
+ * @param {$protobuf.Writer} [writer] Writer to encode to
12818
+ * @returns {$protobuf.Writer} Writer
12819
+ */
12820
+ HeartbeatReq.encode = function encode(message, writer) {
12821
+ if (!writer) writer = $Writer$2.create();
12822
+ if (message.pingId != null && Object.hasOwnProperty.call(message, "pingId")) writer.uint32(/* id 1, wireType 0 =*/8).int64(message.pingId);
12823
+ if (message.disconnectDelay != null && Object.hasOwnProperty.call(message, "disconnectDelay")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.disconnectDelay);
12824
+ return writer;
12825
+ };
12900
12826
 
12901
- /**
12902
- * Decodes a SystemCurrentTimeMillisReq message from the specified reader or buffer.
12903
- * @function decode
12904
- * @memberof SystemCurrentTimeMillisReq
12905
- * @static
12906
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12907
- * @param {number} [length] Message length if known beforehand
12908
- * @returns {SystemCurrentTimeMillisReq} SystemCurrentTimeMillisReq
12909
- * @throws {Error} If the payload is not a reader or valid buffer
12910
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
12911
- */
12912
- SystemCurrentTimeMillisReq.decode = function decode(reader, length) {
12913
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
12914
- var end = length === undefined ? reader.len : reader.pos + length,
12915
- message = new $root.SystemCurrentTimeMillisReq();
12916
- while (reader.pos < end) {
12917
- var tag = reader.uint32();
12918
- switch (tag >>> 3) {
12919
- default:
12920
- reader.skipType(tag & 7);
12827
+ /**
12828
+ * Decodes a HeartbeatReq message from the specified reader or buffer.
12829
+ * @function decode
12830
+ * @memberof HeartbeatReq
12831
+ * @static
12832
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12833
+ * @param {number} [length] Message length if known beforehand
12834
+ * @returns {HeartbeatReq} HeartbeatReq
12835
+ * @throws {Error} If the payload is not a reader or valid buffer
12836
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
12837
+ */
12838
+ HeartbeatReq.decode = function decode(reader, length) {
12839
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
12840
+ let end = length === undefined ? reader.len : reader.pos + length,
12841
+ message = new $root$2.HeartbeatReq();
12842
+ while (reader.pos < end) {
12843
+ let tag = reader.uint32();
12844
+ switch (tag >>> 3) {
12845
+ case 1:
12846
+ {
12847
+ message.pingId = reader.int64();
12921
12848
  break;
12922
- }
12923
- }
12924
- return message;
12925
- };
12926
-
12927
- /**
12928
- * Gets the default type url for SystemCurrentTimeMillisReq
12929
- * @function getTypeUrl
12930
- * @memberof SystemCurrentTimeMillisReq
12931
- * @static
12932
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12933
- * @returns {string} The default type url
12934
- */
12935
- SystemCurrentTimeMillisReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12936
- if (typeUrlPrefix === undefined) {
12937
- typeUrlPrefix = "type.googleapis.com";
12849
+ }
12850
+ case 2:
12851
+ {
12852
+ message.disconnectDelay = reader.int64();
12853
+ break;
12854
+ }
12855
+ default:
12856
+ reader.skipType(tag & 7);
12857
+ break;
12938
12858
  }
12939
- return typeUrlPrefix + "/SystemCurrentTimeMillisReq";
12940
- };
12941
- return SystemCurrentTimeMillisReq;
12942
- }();
12943
- $root.SystemCurrentTimeMillisResp = function () {
12944
- /**
12945
- * Properties of a SystemCurrentTimeMillisResp.
12946
- * @exports ISystemCurrentTimeMillisResp
12947
- * @interface ISystemCurrentTimeMillisResp
12948
- * @property {number|null} [errorCode] SystemCurrentTimeMillisResp errorCode
12949
- * @property {string|null} [errorMessage] SystemCurrentTimeMillisResp errorMessage
12950
- * @property {Long|null} [currentTimeMillis] SystemCurrentTimeMillisResp currentTimeMillis
12951
- */
12952
-
12953
- /**
12954
- * Constructs a new SystemCurrentTimeMillisResp.
12955
- * @exports SystemCurrentTimeMillisResp
12956
- * @classdesc Represents a SystemCurrentTimeMillisResp.
12957
- * @implements ISystemCurrentTimeMillisResp
12958
- * @constructor
12959
- * @param {ISystemCurrentTimeMillisResp=} [properties] Properties to set
12960
- */
12961
- function SystemCurrentTimeMillisResp(properties) {
12962
- if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12963
12859
  }
12860
+ return message;
12861
+ };
12964
12862
 
12965
- /**
12966
- * SystemCurrentTimeMillisResp errorCode.
12967
- * @member {number} errorCode
12968
- * @memberof SystemCurrentTimeMillisResp
12969
- * @instance
12970
- */
12971
- SystemCurrentTimeMillisResp.prototype.errorCode = 0;
12972
-
12973
- /**
12974
- * SystemCurrentTimeMillisResp errorMessage.
12975
- * @member {string} errorMessage
12976
- * @memberof SystemCurrentTimeMillisResp
12977
- * @instance
12978
- */
12979
- SystemCurrentTimeMillisResp.prototype.errorMessage = "";
12980
-
12981
- /**
12982
- * SystemCurrentTimeMillisResp currentTimeMillis.
12983
- * @member {Long} currentTimeMillis
12984
- * @memberof SystemCurrentTimeMillisResp
12985
- * @instance
12986
- */
12987
- SystemCurrentTimeMillisResp.prototype.currentTimeMillis = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12863
+ /**
12864
+ * Gets the default type url for HeartbeatReq
12865
+ * @function getTypeUrl
12866
+ * @memberof HeartbeatReq
12867
+ * @static
12868
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12869
+ * @returns {string} The default type url
12870
+ */
12871
+ HeartbeatReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12872
+ if (typeUrlPrefix === undefined) {
12873
+ typeUrlPrefix = "type.googleapis.com";
12874
+ }
12875
+ return typeUrlPrefix + "/HeartbeatReq";
12876
+ };
12877
+ return HeartbeatReq;
12878
+ })();
12879
+ $root$2.SystemCurrentTimeMillisReq = (() => {
12880
+ /**
12881
+ * Properties of a SystemCurrentTimeMillisReq.
12882
+ * @exports ISystemCurrentTimeMillisReq
12883
+ * @interface ISystemCurrentTimeMillisReq
12884
+ */
12988
12885
 
12989
- /**
12990
- * Encodes the specified SystemCurrentTimeMillisResp message. Does not implicitly {@link SystemCurrentTimeMillisResp.verify|verify} messages.
12991
- * @function encode
12992
- * @memberof SystemCurrentTimeMillisResp
12993
- * @static
12994
- * @param {ISystemCurrentTimeMillisResp} message SystemCurrentTimeMillisResp message or plain object to encode
12995
- * @param {$protobuf.Writer} [writer] Writer to encode to
12996
- * @returns {$protobuf.Writer} Writer
12997
- */
12998
- SystemCurrentTimeMillisResp.encode = function encode(message, writer) {
12999
- if (!writer) writer = $Writer.create();
13000
- if (message.errorCode != null && Object.hasOwnProperty.call(message, "errorCode")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.errorCode);
13001
- if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
13002
- if (message.currentTimeMillis != null && Object.hasOwnProperty.call(message, "currentTimeMillis")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.currentTimeMillis);
13003
- return writer;
13004
- };
12886
+ /**
12887
+ * Constructs a new SystemCurrentTimeMillisReq.
12888
+ * @exports SystemCurrentTimeMillisReq
12889
+ * @classdesc Represents a SystemCurrentTimeMillisReq.
12890
+ * @implements ISystemCurrentTimeMillisReq
12891
+ * @constructor
12892
+ * @param {ISystemCurrentTimeMillisReq=} [properties] Properties to set
12893
+ */
12894
+ function SystemCurrentTimeMillisReq(properties) {
12895
+ if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12896
+ }
13005
12897
 
13006
- /**
13007
- * Decodes a SystemCurrentTimeMillisResp message from the specified reader or buffer.
13008
- * @function decode
13009
- * @memberof SystemCurrentTimeMillisResp
13010
- * @static
13011
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
13012
- * @param {number} [length] Message length if known beforehand
13013
- * @returns {SystemCurrentTimeMillisResp} SystemCurrentTimeMillisResp
13014
- * @throws {Error} If the payload is not a reader or valid buffer
13015
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
13016
- */
13017
- SystemCurrentTimeMillisResp.decode = function decode(reader, length) {
13018
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
13019
- var end = length === undefined ? reader.len : reader.pos + length,
13020
- message = new $root.SystemCurrentTimeMillisResp();
13021
- while (reader.pos < end) {
13022
- var tag = reader.uint32();
13023
- switch (tag >>> 3) {
13024
- case 1:
13025
- {
13026
- message.errorCode = reader.int32();
13027
- break;
13028
- }
13029
- case 2:
13030
- {
13031
- message.errorMessage = reader.string();
13032
- break;
13033
- }
13034
- case 3:
13035
- {
13036
- message.currentTimeMillis = reader.int64();
13037
- break;
13038
- }
13039
- default:
13040
- reader.skipType(tag & 7);
13041
- break;
13042
- }
13043
- }
13044
- return message;
13045
- };
12898
+ /**
12899
+ * Encodes the specified SystemCurrentTimeMillisReq message. Does not implicitly {@link SystemCurrentTimeMillisReq.verify|verify} messages.
12900
+ * @function encode
12901
+ * @memberof SystemCurrentTimeMillisReq
12902
+ * @static
12903
+ * @param {ISystemCurrentTimeMillisReq} message SystemCurrentTimeMillisReq message or plain object to encode
12904
+ * @param {$protobuf.Writer} [writer] Writer to encode to
12905
+ * @returns {$protobuf.Writer} Writer
12906
+ */
12907
+ SystemCurrentTimeMillisReq.encode = function encode(message, writer) {
12908
+ if (!writer) writer = $Writer$2.create();
12909
+ return writer;
12910
+ };
13046
12911
 
13047
- /**
13048
- * Gets the default type url for SystemCurrentTimeMillisResp
13049
- * @function getTypeUrl
13050
- * @memberof SystemCurrentTimeMillisResp
13051
- * @static
13052
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
13053
- * @returns {string} The default type url
13054
- */
13055
- SystemCurrentTimeMillisResp.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
13056
- if (typeUrlPrefix === undefined) {
13057
- typeUrlPrefix = "type.googleapis.com";
12912
+ /**
12913
+ * Decodes a SystemCurrentTimeMillisReq message from the specified reader or buffer.
12914
+ * @function decode
12915
+ * @memberof SystemCurrentTimeMillisReq
12916
+ * @static
12917
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12918
+ * @param {number} [length] Message length if known beforehand
12919
+ * @returns {SystemCurrentTimeMillisReq} SystemCurrentTimeMillisReq
12920
+ * @throws {Error} If the payload is not a reader or valid buffer
12921
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
12922
+ */
12923
+ SystemCurrentTimeMillisReq.decode = function decode(reader, length) {
12924
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
12925
+ let end = length === undefined ? reader.len : reader.pos + length,
12926
+ message = new $root$2.SystemCurrentTimeMillisReq();
12927
+ while (reader.pos < end) {
12928
+ let tag = reader.uint32();
12929
+ switch (tag >>> 3) {
12930
+ default:
12931
+ reader.skipType(tag & 7);
12932
+ break;
13058
12933
  }
13059
- return typeUrlPrefix + "/SystemCurrentTimeMillisResp";
13060
- };
13061
- return SystemCurrentTimeMillisResp;
13062
- }();
13063
- $root.BaseResp = function () {
13064
- /**
13065
- * Properties of a BaseResp.
13066
- * @exports IBaseResp
13067
- * @interface IBaseResp
13068
- * @property {number|null} [errorCode] BaseResp errorCode
13069
- * @property {string|null} [errorMessage] BaseResp errorMessage
13070
- */
12934
+ }
12935
+ return message;
12936
+ };
13071
12937
 
13072
- /**
13073
- * Constructs a new BaseResp.
13074
- * @exports BaseResp
13075
- * @classdesc Represents a BaseResp.
13076
- * @implements IBaseResp
13077
- * @constructor
13078
- * @param {IBaseResp=} [properties] Properties to set
13079
- */
13080
- function BaseResp(properties) {
13081
- if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12938
+ /**
12939
+ * Gets the default type url for SystemCurrentTimeMillisReq
12940
+ * @function getTypeUrl
12941
+ * @memberof SystemCurrentTimeMillisReq
12942
+ * @static
12943
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12944
+ * @returns {string} The default type url
12945
+ */
12946
+ SystemCurrentTimeMillisReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12947
+ if (typeUrlPrefix === undefined) {
12948
+ typeUrlPrefix = "type.googleapis.com";
13082
12949
  }
12950
+ return typeUrlPrefix + "/SystemCurrentTimeMillisReq";
12951
+ };
12952
+ return SystemCurrentTimeMillisReq;
12953
+ })();
12954
+ const SystemCurrentTimeMillisResp = $root$2.SystemCurrentTimeMillisResp = (() => {
12955
+ /**
12956
+ * Properties of a SystemCurrentTimeMillisResp.
12957
+ * @exports ISystemCurrentTimeMillisResp
12958
+ * @interface ISystemCurrentTimeMillisResp
12959
+ * @property {number|null} [errorCode] SystemCurrentTimeMillisResp errorCode
12960
+ * @property {string|null} [errorMessage] SystemCurrentTimeMillisResp errorMessage
12961
+ * @property {Long|null} [currentTimeMillis] SystemCurrentTimeMillisResp currentTimeMillis
12962
+ */
13083
12963
 
13084
- /**
13085
- * BaseResp errorCode.
13086
- * @member {number} errorCode
13087
- * @memberof BaseResp
13088
- * @instance
13089
- */
13090
- BaseResp.prototype.errorCode = 0;
12964
+ /**
12965
+ * Constructs a new SystemCurrentTimeMillisResp.
12966
+ * @exports SystemCurrentTimeMillisResp
12967
+ * @classdesc Represents a SystemCurrentTimeMillisResp.
12968
+ * @implements ISystemCurrentTimeMillisResp
12969
+ * @constructor
12970
+ * @param {ISystemCurrentTimeMillisResp=} [properties] Properties to set
12971
+ */
12972
+ function SystemCurrentTimeMillisResp(properties) {
12973
+ if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
12974
+ }
13091
12975
 
13092
- /**
13093
- * BaseResp errorMessage.
13094
- * @member {string} errorMessage
13095
- * @memberof BaseResp
13096
- * @instance
13097
- */
13098
- BaseResp.prototype.errorMessage = "";
12976
+ /**
12977
+ * SystemCurrentTimeMillisResp errorCode.
12978
+ * @member {number} errorCode
12979
+ * @memberof SystemCurrentTimeMillisResp
12980
+ * @instance
12981
+ */
12982
+ SystemCurrentTimeMillisResp.prototype.errorCode = 0;
13099
12983
 
13100
- /**
13101
- * Encodes the specified BaseResp message. Does not implicitly {@link BaseResp.verify|verify} messages.
13102
- * @function encode
13103
- * @memberof BaseResp
13104
- * @static
13105
- * @param {IBaseResp} message BaseResp message or plain object to encode
13106
- * @param {$protobuf.Writer} [writer] Writer to encode to
13107
- * @returns {$protobuf.Writer} Writer
13108
- */
13109
- BaseResp.encode = function encode(message, writer) {
13110
- if (!writer) writer = $Writer.create();
13111
- if (message.errorCode != null && Object.hasOwnProperty.call(message, "errorCode")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.errorCode);
13112
- if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
13113
- return writer;
13114
- };
12984
+ /**
12985
+ * SystemCurrentTimeMillisResp errorMessage.
12986
+ * @member {string} errorMessage
12987
+ * @memberof SystemCurrentTimeMillisResp
12988
+ * @instance
12989
+ */
12990
+ SystemCurrentTimeMillisResp.prototype.errorMessage = "";
13115
12991
 
13116
- /**
13117
- * Decodes a BaseResp message from the specified reader or buffer.
13118
- * @function decode
13119
- * @memberof BaseResp
13120
- * @static
13121
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
13122
- * @param {number} [length] Message length if known beforehand
13123
- * @returns {BaseResp} BaseResp
13124
- * @throws {Error} If the payload is not a reader or valid buffer
13125
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
13126
- */
13127
- BaseResp.decode = function decode(reader, length) {
13128
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
13129
- var end = length === undefined ? reader.len : reader.pos + length,
13130
- message = new $root.BaseResp();
13131
- while (reader.pos < end) {
13132
- var tag = reader.uint32();
13133
- switch (tag >>> 3) {
13134
- case 1:
13135
- {
13136
- message.errorCode = reader.int32();
13137
- break;
13138
- }
13139
- case 2:
13140
- {
13141
- message.errorMessage = reader.string();
13142
- break;
13143
- }
13144
- default:
13145
- reader.skipType(tag & 7);
12992
+ /**
12993
+ * SystemCurrentTimeMillisResp currentTimeMillis.
12994
+ * @member {Long} currentTimeMillis
12995
+ * @memberof SystemCurrentTimeMillisResp
12996
+ * @instance
12997
+ */
12998
+ SystemCurrentTimeMillisResp.prototype.currentTimeMillis = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12999
+
13000
+ /**
13001
+ * Encodes the specified SystemCurrentTimeMillisResp message. Does not implicitly {@link SystemCurrentTimeMillisResp.verify|verify} messages.
13002
+ * @function encode
13003
+ * @memberof SystemCurrentTimeMillisResp
13004
+ * @static
13005
+ * @param {ISystemCurrentTimeMillisResp} message SystemCurrentTimeMillisResp message or plain object to encode
13006
+ * @param {$protobuf.Writer} [writer] Writer to encode to
13007
+ * @returns {$protobuf.Writer} Writer
13008
+ */
13009
+ SystemCurrentTimeMillisResp.encode = function encode(message, writer) {
13010
+ if (!writer) writer = $Writer$2.create();
13011
+ if (message.errorCode != null && Object.hasOwnProperty.call(message, "errorCode")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.errorCode);
13012
+ if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
13013
+ if (message.currentTimeMillis != null && Object.hasOwnProperty.call(message, "currentTimeMillis")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.currentTimeMillis);
13014
+ return writer;
13015
+ };
13016
+
13017
+ /**
13018
+ * Decodes a SystemCurrentTimeMillisResp message from the specified reader or buffer.
13019
+ * @function decode
13020
+ * @memberof SystemCurrentTimeMillisResp
13021
+ * @static
13022
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
13023
+ * @param {number} [length] Message length if known beforehand
13024
+ * @returns {SystemCurrentTimeMillisResp} SystemCurrentTimeMillisResp
13025
+ * @throws {Error} If the payload is not a reader or valid buffer
13026
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
13027
+ */
13028
+ SystemCurrentTimeMillisResp.decode = function decode(reader, length) {
13029
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
13030
+ let end = length === undefined ? reader.len : reader.pos + length,
13031
+ message = new $root$2.SystemCurrentTimeMillisResp();
13032
+ while (reader.pos < end) {
13033
+ let tag = reader.uint32();
13034
+ switch (tag >>> 3) {
13035
+ case 1:
13036
+ {
13037
+ message.errorCode = reader.int32();
13146
13038
  break;
13147
- }
13039
+ }
13040
+ case 2:
13041
+ {
13042
+ message.errorMessage = reader.string();
13043
+ break;
13044
+ }
13045
+ case 3:
13046
+ {
13047
+ message.currentTimeMillis = reader.int64();
13048
+ break;
13049
+ }
13050
+ default:
13051
+ reader.skipType(tag & 7);
13052
+ break;
13148
13053
  }
13149
- return message;
13150
- };
13054
+ }
13055
+ return message;
13056
+ };
13151
13057
 
13152
- /**
13153
- * Gets the default type url for BaseResp
13154
- * @function getTypeUrl
13155
- * @memberof BaseResp
13156
- * @static
13157
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
13158
- * @returns {string} The default type url
13159
- */
13160
- BaseResp.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
13161
- if (typeUrlPrefix === undefined) {
13162
- typeUrlPrefix = "type.googleapis.com";
13058
+ /**
13059
+ * Gets the default type url for SystemCurrentTimeMillisResp
13060
+ * @function getTypeUrl
13061
+ * @memberof SystemCurrentTimeMillisResp
13062
+ * @static
13063
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
13064
+ * @returns {string} The default type url
13065
+ */
13066
+ SystemCurrentTimeMillisResp.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
13067
+ if (typeUrlPrefix === undefined) {
13068
+ typeUrlPrefix = "type.googleapis.com";
13069
+ }
13070
+ return typeUrlPrefix + "/SystemCurrentTimeMillisResp";
13071
+ };
13072
+ return SystemCurrentTimeMillisResp;
13073
+ })();
13074
+ const BaseResp = $root$2.BaseResp = (() => {
13075
+ /**
13076
+ * Properties of a BaseResp.
13077
+ * @exports IBaseResp
13078
+ * @interface IBaseResp
13079
+ * @property {number|null} [errorCode] BaseResp errorCode
13080
+ * @property {string|null} [errorMessage] BaseResp errorMessage
13081
+ */
13082
+
13083
+ /**
13084
+ * Constructs a new BaseResp.
13085
+ * @exports BaseResp
13086
+ * @classdesc Represents a BaseResp.
13087
+ * @implements IBaseResp
13088
+ * @constructor
13089
+ * @param {IBaseResp=} [properties] Properties to set
13090
+ */
13091
+ function BaseResp(properties) {
13092
+ if (properties) for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
13093
+ }
13094
+
13095
+ /**
13096
+ * BaseResp errorCode.
13097
+ * @member {number} errorCode
13098
+ * @memberof BaseResp
13099
+ * @instance
13100
+ */
13101
+ BaseResp.prototype.errorCode = 0;
13102
+
13103
+ /**
13104
+ * BaseResp errorMessage.
13105
+ * @member {string} errorMessage
13106
+ * @memberof BaseResp
13107
+ * @instance
13108
+ */
13109
+ BaseResp.prototype.errorMessage = "";
13110
+
13111
+ /**
13112
+ * Encodes the specified BaseResp message. Does not implicitly {@link BaseResp.verify|verify} messages.
13113
+ * @function encode
13114
+ * @memberof BaseResp
13115
+ * @static
13116
+ * @param {IBaseResp} message BaseResp message or plain object to encode
13117
+ * @param {$protobuf.Writer} [writer] Writer to encode to
13118
+ * @returns {$protobuf.Writer} Writer
13119
+ */
13120
+ BaseResp.encode = function encode(message, writer) {
13121
+ if (!writer) writer = $Writer$2.create();
13122
+ if (message.errorCode != null && Object.hasOwnProperty.call(message, "errorCode")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.errorCode);
13123
+ if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
13124
+ return writer;
13125
+ };
13126
+
13127
+ /**
13128
+ * Decodes a BaseResp message from the specified reader or buffer.
13129
+ * @function decode
13130
+ * @memberof BaseResp
13131
+ * @static
13132
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
13133
+ * @param {number} [length] Message length if known beforehand
13134
+ * @returns {BaseResp} BaseResp
13135
+ * @throws {Error} If the payload is not a reader or valid buffer
13136
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
13137
+ */
13138
+ BaseResp.decode = function decode(reader, length) {
13139
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
13140
+ let end = length === undefined ? reader.len : reader.pos + length,
13141
+ message = new $root$2.BaseResp();
13142
+ while (reader.pos < end) {
13143
+ let tag = reader.uint32();
13144
+ switch (tag >>> 3) {
13145
+ case 1:
13146
+ {
13147
+ message.errorCode = reader.int32();
13148
+ break;
13149
+ }
13150
+ case 2:
13151
+ {
13152
+ message.errorMessage = reader.string();
13153
+ break;
13154
+ }
13155
+ default:
13156
+ reader.skipType(tag & 7);
13157
+ break;
13163
13158
  }
13164
- return typeUrlPrefix + "/BaseResp";
13165
- };
13166
- return BaseResp;
13167
- }();
13168
- rpc_base = $root;
13169
- return rpc_base;
13170
- }
13159
+ }
13160
+ return message;
13161
+ };
13171
13162
 
13172
- var rpc_baseExports = requireRpc_base();
13163
+ /**
13164
+ * Gets the default type url for BaseResp
13165
+ * @function getTypeUrl
13166
+ * @memberof BaseResp
13167
+ * @static
13168
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
13169
+ * @returns {string} The default type url
13170
+ */
13171
+ BaseResp.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
13172
+ if (typeUrlPrefix === undefined) {
13173
+ typeUrlPrefix = "type.googleapis.com";
13174
+ }
13175
+ return typeUrlPrefix + "/BaseResp";
13176
+ };
13177
+ return BaseResp;
13178
+ })();
13173
13179
 
13174
13180
  class StreamWriter {
13175
13181
  pool = [];
@@ -13288,6 +13294,31 @@
13288
13294
  }
13289
13295
  var accountStore = new AccountStore();
13290
13296
 
13297
+ class IMConfig {
13298
+ uploader = undefined;
13299
+ deviceCode = undefined;
13300
+ deviceType = 7;
13301
+ getUploader() {
13302
+ return this.uploader;
13303
+ }
13304
+ setUploader(uploader) {
13305
+ this.uploader = uploader;
13306
+ }
13307
+ getDeviceCode() {
13308
+ return this.deviceCode;
13309
+ }
13310
+ setDeviceCode(deviceCode) {
13311
+ this.deviceCode = deviceCode;
13312
+ }
13313
+ getDeviceType() {
13314
+ return this.deviceType;
13315
+ }
13316
+ setDeviceType(deviceType) {
13317
+ this.deviceType = deviceType;
13318
+ }
13319
+ }
13320
+ var imConfig = new IMConfig();
13321
+
13291
13322
  const DefaultOptions = {
13292
13323
  webSocketTimeout: 5000,
13293
13324
  signalTimeout: 30000,
@@ -13429,12 +13460,13 @@
13429
13460
  protocolVersion: SOCKET_PROTOCOL_VER,
13430
13461
  destId: '',
13431
13462
  body: body,
13432
- deviceType: 7
13463
+ deviceCode: imConfig.getDeviceCode() ?? "",
13464
+ deviceType: imConfig.getDeviceType()
13433
13465
  };
13434
13466
  if (cmdId !== CmdIds$1.Heartbean) {
13435
13467
  logger.info(`websocket send -> cmd: 0x${cmdId.toString(16)}, messageSeq: ${messageSeq}`);
13436
13468
  }
13437
- this.socket?.send(buildWsPacketData(rpc_baseExports.NetworkRequest.encode(networkReq).finish()));
13469
+ this.socket?.send(buildWsPacketData(NetworkRequest.encode(networkReq).finish()));
13438
13470
  }
13439
13471
  close() {
13440
13472
  this.autoReconnect = false;
@@ -13488,7 +13520,7 @@
13488
13520
  const {
13489
13521
  code
13490
13522
  } = await this.send(CmdIds$1.Heartbean, heartbeat, {
13491
- encoder: rpc_baseExports.HeartbeatReq
13523
+ encoder: HeartbeatReq
13492
13524
  }, this.options.pingTimeout);
13493
13525
  if (code === exports.ErrorCode.SUCCESS) {
13494
13526
  logger.debug('recv pong <-');
@@ -13510,7 +13542,7 @@
13510
13542
  let networkResponse;
13511
13543
  try {
13512
13544
  const payload = resolvePacketData(data);
13513
- networkResponse = rpc_baseExports.NetworkResponse.decode(payload);
13545
+ networkResponse = NetworkResponse.decode(payload);
13514
13546
  } catch (error) {
13515
13547
  logger.error('unpack payload error -> ', error);
13516
13548
  this.onDisconnect(exports.ConnectionStatus.DISCONNECT_BY_SERVER);
@@ -13642,8 +13674,6 @@
13642
13674
  };
13643
13675
  var webSocketServer = new WebSocketServer();
13644
13676
 
13645
- var minimalExports = requireMinimal();
13646
-
13647
13677
  /*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
13648
13678
 
13649
13679
  // Common aliases
@@ -18459,7 +18489,7 @@
18459
18489
  };
18460
18490
 
18461
18491
  const getServerTime$2 = () => webSocketServer.send(CmdIds$1.GetServerTime, null, {
18462
- decoder: rpc_baseExports.SystemCurrentTimeMillisResp
18492
+ decoder: SystemCurrentTimeMillisResp
18463
18493
  });
18464
18494
  const getDialogKey = dialogIds => webSocketServer.send(CmdIds$1.GetDialogKey, {
18465
18495
  destId: dialogIds,
@@ -18494,7 +18524,7 @@
18494
18524
  msgId: Long.fromString(messageUId)
18495
18525
  }, {
18496
18526
  encoder: RecallGroupChatMessageReq,
18497
- decoder: rpc_baseExports.BaseResp
18527
+ decoder: BaseResp
18498
18528
  });
18499
18529
  } else {
18500
18530
  reqPromise = webSocketServer.send(CmdIds$1.RecallPrivateMessage, {
@@ -18502,7 +18532,7 @@
18502
18532
  msgId: Long.fromString(messageUId)
18503
18533
  }, {
18504
18534
  encoder: RecallPrivateChatMessageReq,
18505
- decoder: rpc_baseExports.BaseResp
18535
+ decoder: BaseResp
18506
18536
  });
18507
18537
  }
18508
18538
  return reqPromise;
@@ -18529,7 +18559,7 @@
18529
18559
  msgIdList: messageUIds.map(e => Long.fromString(e))
18530
18560
  }, {
18531
18561
  encoder: DeleteChatMessageReq,
18532
- decoder: rpc_baseExports.BaseResp
18562
+ decoder: BaseResp
18533
18563
  });
18534
18564
  return reqPromise;
18535
18565
  };
@@ -18540,7 +18570,7 @@
18540
18570
  msgTime: Long.fromNumber(timestamp)
18541
18571
  }, {
18542
18572
  encoder: CleanHistoryMessageReq,
18543
- decoder: rpc_baseExports.BaseResp
18573
+ decoder: BaseResp
18544
18574
  });
18545
18575
  };
18546
18576
  const getDialogList = params => webSocketServer.send(CmdIds$1.GetDialogList, params, {
@@ -18563,7 +18593,7 @@
18563
18593
  muteFlag
18564
18594
  }, {
18565
18595
  encoder: UpdateGroupChatDialogMuteConfigReq,
18566
- decoder: rpc_baseExports.BaseResp
18596
+ decoder: BaseResp
18567
18597
  });
18568
18598
  } else {
18569
18599
  reqPromise = webSocketServer.send(CmdIds$1.UpdatePrivateChatMuteConfig, {
@@ -18571,7 +18601,7 @@
18571
18601
  muteFlag
18572
18602
  }, {
18573
18603
  encoder: UpdatePrivateChatDialogMuteConfigReq,
18574
- decoder: rpc_baseExports.BaseResp
18604
+ decoder: BaseResp
18575
18605
  });
18576
18606
  }
18577
18607
  return reqPromise;
@@ -18584,7 +18614,7 @@
18584
18614
  stickyFlag
18585
18615
  }, {
18586
18616
  encoder: UpdateGroupChatDialogStickyConfigReq,
18587
- decoder: rpc_baseExports.BaseResp
18617
+ decoder: BaseResp
18588
18618
  });
18589
18619
  } else {
18590
18620
  reqPromise = webSocketServer.send(CmdIds$1.UpdatePrivateChatStickyConfig, {
@@ -18592,7 +18622,7 @@
18592
18622
  stickyFlag
18593
18623
  }, {
18594
18624
  encoder: UpdatePrivateChatDialogStickyConfigReq,
18595
- decoder: rpc_baseExports.BaseResp
18625
+ decoder: BaseResp
18596
18626
  });
18597
18627
  }
18598
18628
  return reqPromise;
@@ -18604,14 +18634,14 @@
18604
18634
  groupId: Long.fromString(dialogId)
18605
18635
  }, {
18606
18636
  encoder: DeleteGroupChatDialogReq,
18607
- decoder: rpc_baseExports.BaseResp
18637
+ decoder: BaseResp
18608
18638
  });
18609
18639
  } else {
18610
18640
  reqPromise = webSocketServer.send(CmdIds$1.DeletePrivateDialog, {
18611
18641
  destId: Long.fromString(dialogId)
18612
18642
  }, {
18613
18643
  encoder: DeletePrivateChatDialogReq,
18614
- decoder: rpc_baseExports.BaseResp
18644
+ decoder: BaseResp
18615
18645
  });
18616
18646
  }
18617
18647
  return reqPromise;
@@ -26665,17 +26695,6 @@
26665
26695
  var protobufjsExports = requireProtobufjs();
26666
26696
  var protobuf = /*@__PURE__*/getDefaultExportFromCjs(protobufjsExports);
26667
26697
 
26668
- class IMConfig {
26669
- uploader = undefined;
26670
- getUploader() {
26671
- return this.uploader;
26672
- }
26673
- setUploader(uploader) {
26674
- this.uploader = uploader;
26675
- }
26676
- }
26677
- var imConfig = new IMConfig();
26678
-
26679
26698
  const transSentAttrs2IReceivedMessage = (message, options, sentStatus = exports.SentStatus.SENDING) => ({
26680
26699
  conversationType: options.conversation.conversationType,
26681
26700
  targetId: options.conversation.targetId,
@@ -27379,6 +27398,8 @@
27379
27398
  if (isDef(options.uploader)) {
27380
27399
  imConfig.setUploader(options.uploader);
27381
27400
  }
27401
+ imConfig.setDeviceCode(options.deviceCode);
27402
+ imConfig.setDeviceType(options.deviceType);
27382
27403
  this.libLoader = LibLoader.init(options);
27383
27404
  this.watch();
27384
27405
  IMClient.imClient = this;
@@ -28538,7 +28559,7 @@
28538
28559
  imClient.once(eventType, listener, target);
28539
28560
  }
28540
28561
  const removeEventListener = (eventType, listener, target) => {
28541
- imClient.off(eventType, listener, target);
28562
+ imClient?.off(eventType, listener, target);
28542
28563
  };
28543
28564
  const getConversationList = async options => {
28544
28565
  logger.debug('get conversation list ->');