@onyx-p/imlib-web 1.5.7 → 1.5.9

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.esm.js CHANGED
@@ -12349,821 +12349,827 @@ function requireMinimal () {
12349
12349
  return minimal;
12350
12350
  }
12351
12351
 
12352
+ var minimalExports = requireMinimal();
12353
+
12352
12354
  /*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
12353
- var rpc_base;
12354
- var hasRequiredRpc_base;
12355
- function requireRpc_base() {
12356
- if (hasRequiredRpc_base) return rpc_base;
12357
- hasRequiredRpc_base = 1;
12358
- var $protobuf = requireMinimal();
12359
12355
 
12360
- // Common aliases
12361
- var $Reader = $protobuf.Reader,
12362
- $Writer = $protobuf.Writer,
12363
- $util = $protobuf.util;
12356
+ // Common aliases
12357
+ const $Reader$2 = minimalExports.Reader,
12358
+ $Writer$2 = minimalExports.Writer,
12359
+ $util$2 = minimalExports.util;
12364
12360
 
12365
- // Exported root namespace
12366
- var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
12367
- $root.NetworkRequest = function () {
12368
- /**
12369
- * Properties of a NetworkRequest.
12370
- * @exports INetworkRequest
12371
- * @interface INetworkRequest
12372
- * @property {number|null} [cmdId] NetworkRequest cmdId
12373
- * @property {Long|null} [messageSeq] NetworkRequest messageSeq
12374
- * @property {Long|null} [deviceId] NetworkRequest deviceId
12375
- * @property {Long|null} [sessionId] NetworkRequest sessionId
12376
- * @property {Long|null} [uid] NetworkRequest uid
12377
- * @property {number|null} [protocolVersion] NetworkRequest protocolVersion
12378
- * @property {string|null} [destId] NetworkRequest destId
12379
- * @property {Uint8Array|null} [body] NetworkRequest body
12380
- * @property {number|null} [deviceType] NetworkRequest deviceType
12381
- */
12361
+ // Exported root namespace
12362
+ const $root$2 = minimalExports.roots["default"] || (minimalExports.roots["default"] = {});
12363
+ const NetworkRequest = $root$2.NetworkRequest = (() => {
12364
+ /**
12365
+ * Properties of a NetworkRequest.
12366
+ * @exports INetworkRequest
12367
+ * @interface INetworkRequest
12368
+ * @property {number|null} [cmdId] NetworkRequest cmdId
12369
+ * @property {Long|null} [messageSeq] NetworkRequest messageSeq
12370
+ * @property {Long|null} [deviceId] NetworkRequest deviceId
12371
+ * @property {Long|null} [sessionId] NetworkRequest sessionId
12372
+ * @property {Long|null} [uid] NetworkRequest uid
12373
+ * @property {number|null} [protocolVersion] NetworkRequest protocolVersion
12374
+ * @property {string|null} [destId] NetworkRequest destId
12375
+ * @property {Uint8Array|null} [body] NetworkRequest body
12376
+ * @property {string|null} [deviceCode] NetworkRequest deviceCode
12377
+ * @property {number|null} [deviceType] NetworkRequest deviceType
12378
+ */
12379
+
12380
+ /**
12381
+ * Constructs a new NetworkRequest.
12382
+ * @exports NetworkRequest
12383
+ * @classdesc Represents a NetworkRequest.
12384
+ * @implements INetworkRequest
12385
+ * @constructor
12386
+ * @param {INetworkRequest=} [properties] Properties to set
12387
+ */
12388
+ function NetworkRequest(properties) {
12389
+ 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]];
12390
+ }
12382
12391
 
12383
- /**
12384
- * Constructs a new NetworkRequest.
12385
- * @exports NetworkRequest
12386
- * @classdesc Represents a NetworkRequest.
12387
- * @implements INetworkRequest
12388
- * @constructor
12389
- * @param {INetworkRequest=} [properties] Properties to set
12390
- */
12391
- function NetworkRequest(properties) {
12392
- 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]];
12393
- }
12392
+ /**
12393
+ * NetworkRequest cmdId.
12394
+ * @member {number} cmdId
12395
+ * @memberof NetworkRequest
12396
+ * @instance
12397
+ */
12398
+ NetworkRequest.prototype.cmdId = 0;
12394
12399
 
12395
- /**
12396
- * NetworkRequest cmdId.
12397
- * @member {number} cmdId
12398
- * @memberof NetworkRequest
12399
- * @instance
12400
- */
12401
- NetworkRequest.prototype.cmdId = 0;
12400
+ /**
12401
+ * NetworkRequest messageSeq.
12402
+ * @member {Long} messageSeq
12403
+ * @memberof NetworkRequest
12404
+ * @instance
12405
+ */
12406
+ NetworkRequest.prototype.messageSeq = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12402
12407
 
12403
- /**
12404
- * NetworkRequest messageSeq.
12405
- * @member {Long} messageSeq
12406
- * @memberof NetworkRequest
12407
- * @instance
12408
- */
12409
- NetworkRequest.prototype.messageSeq = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12408
+ /**
12409
+ * NetworkRequest deviceId.
12410
+ * @member {Long} deviceId
12411
+ * @memberof NetworkRequest
12412
+ * @instance
12413
+ */
12414
+ NetworkRequest.prototype.deviceId = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12410
12415
 
12411
- /**
12412
- * NetworkRequest deviceId.
12413
- * @member {Long} deviceId
12414
- * @memberof NetworkRequest
12415
- * @instance
12416
- */
12417
- NetworkRequest.prototype.deviceId = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12416
+ /**
12417
+ * NetworkRequest sessionId.
12418
+ * @member {Long} sessionId
12419
+ * @memberof NetworkRequest
12420
+ * @instance
12421
+ */
12422
+ NetworkRequest.prototype.sessionId = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12418
12423
 
12419
- /**
12420
- * NetworkRequest sessionId.
12421
- * @member {Long} sessionId
12422
- * @memberof NetworkRequest
12423
- * @instance
12424
- */
12425
- NetworkRequest.prototype.sessionId = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12424
+ /**
12425
+ * NetworkRequest uid.
12426
+ * @member {Long} uid
12427
+ * @memberof NetworkRequest
12428
+ * @instance
12429
+ */
12430
+ NetworkRequest.prototype.uid = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12426
12431
 
12427
- /**
12428
- * NetworkRequest uid.
12429
- * @member {Long} uid
12430
- * @memberof NetworkRequest
12431
- * @instance
12432
- */
12433
- NetworkRequest.prototype.uid = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12432
+ /**
12433
+ * NetworkRequest protocolVersion.
12434
+ * @member {number} protocolVersion
12435
+ * @memberof NetworkRequest
12436
+ * @instance
12437
+ */
12438
+ NetworkRequest.prototype.protocolVersion = 0;
12434
12439
 
12435
- /**
12436
- * NetworkRequest protocolVersion.
12437
- * @member {number} protocolVersion
12438
- * @memberof NetworkRequest
12439
- * @instance
12440
- */
12441
- NetworkRequest.prototype.protocolVersion = 0;
12440
+ /**
12441
+ * NetworkRequest destId.
12442
+ * @member {string} destId
12443
+ * @memberof NetworkRequest
12444
+ * @instance
12445
+ */
12446
+ NetworkRequest.prototype.destId = "";
12442
12447
 
12443
- /**
12444
- * NetworkRequest destId.
12445
- * @member {string} destId
12446
- * @memberof NetworkRequest
12447
- * @instance
12448
- */
12449
- NetworkRequest.prototype.destId = "";
12448
+ /**
12449
+ * NetworkRequest body.
12450
+ * @member {Uint8Array} body
12451
+ * @memberof NetworkRequest
12452
+ * @instance
12453
+ */
12454
+ NetworkRequest.prototype.body = $util$2.newBuffer([]);
12450
12455
 
12451
- /**
12452
- * NetworkRequest body.
12453
- * @member {Uint8Array} body
12454
- * @memberof NetworkRequest
12455
- * @instance
12456
- */
12457
- NetworkRequest.prototype.body = $util.newBuffer([]);
12456
+ /**
12457
+ * NetworkRequest deviceCode.
12458
+ * @member {string} deviceCode
12459
+ * @memberof NetworkRequest
12460
+ * @instance
12461
+ */
12462
+ NetworkRequest.prototype.deviceCode = "";
12458
12463
 
12459
- /**
12460
- * NetworkRequest deviceType.
12461
- * @member {number} deviceType
12462
- * @memberof NetworkRequest
12463
- * @instance
12464
- */
12465
- NetworkRequest.prototype.deviceType = 0;
12464
+ /**
12465
+ * NetworkRequest deviceType.
12466
+ * @member {number} deviceType
12467
+ * @memberof NetworkRequest
12468
+ * @instance
12469
+ */
12470
+ NetworkRequest.prototype.deviceType = 0;
12466
12471
 
12467
- /**
12468
- * Encodes the specified NetworkRequest message. Does not implicitly {@link NetworkRequest.verify|verify} messages.
12469
- * @function encode
12470
- * @memberof NetworkRequest
12471
- * @static
12472
- * @param {INetworkRequest} message NetworkRequest message or plain object to encode
12473
- * @param {$protobuf.Writer} [writer] Writer to encode to
12474
- * @returns {$protobuf.Writer} Writer
12475
- */
12476
- NetworkRequest.encode = function encode(message, writer) {
12477
- if (!writer) writer = $Writer.create();
12478
- if (message.cmdId != null && Object.hasOwnProperty.call(message, "cmdId")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.cmdId);
12479
- if (message.messageSeq != null && Object.hasOwnProperty.call(message, "messageSeq")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.messageSeq);
12480
- if (message.deviceId != null && Object.hasOwnProperty.call(message, "deviceId")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.deviceId);
12481
- if (message.sessionId != null && Object.hasOwnProperty.call(message, "sessionId")) writer.uint32(/* id 4, wireType 0 =*/32).int64(message.sessionId);
12482
- if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) writer.uint32(/* id 5, wireType 0 =*/40).int64(message.uid);
12483
- if (message.protocolVersion != null && Object.hasOwnProperty.call(message, "protocolVersion")) writer.uint32(/* id 6, wireType 0 =*/48).int32(message.protocolVersion);
12484
- if (message.destId != null && Object.hasOwnProperty.call(message, "destId")) writer.uint32(/* id 7, wireType 2 =*/58).string(message.destId);
12485
- if (message.body != null && Object.hasOwnProperty.call(message, "body")) writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.body);
12486
- if (message.deviceType != null && Object.hasOwnProperty.call(message, "deviceType")) writer.uint32(/* id 12, wireType 0 =*/96).int32(message.deviceType);
12487
- return writer;
12488
- };
12472
+ /**
12473
+ * Encodes the specified NetworkRequest message. Does not implicitly {@link NetworkRequest.verify|verify} messages.
12474
+ * @function encode
12475
+ * @memberof NetworkRequest
12476
+ * @static
12477
+ * @param {INetworkRequest} message NetworkRequest message or plain object to encode
12478
+ * @param {$protobuf.Writer} [writer] Writer to encode to
12479
+ * @returns {$protobuf.Writer} Writer
12480
+ */
12481
+ NetworkRequest.encode = function encode(message, writer) {
12482
+ if (!writer) writer = $Writer$2.create();
12483
+ if (message.cmdId != null && Object.hasOwnProperty.call(message, "cmdId")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.cmdId);
12484
+ if (message.messageSeq != null && Object.hasOwnProperty.call(message, "messageSeq")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.messageSeq);
12485
+ if (message.deviceId != null && Object.hasOwnProperty.call(message, "deviceId")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.deviceId);
12486
+ if (message.sessionId != null && Object.hasOwnProperty.call(message, "sessionId")) writer.uint32(/* id 4, wireType 0 =*/32).int64(message.sessionId);
12487
+ if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) writer.uint32(/* id 5, wireType 0 =*/40).int64(message.uid);
12488
+ if (message.protocolVersion != null && Object.hasOwnProperty.call(message, "protocolVersion")) writer.uint32(/* id 6, wireType 0 =*/48).int32(message.protocolVersion);
12489
+ if (message.destId != null && Object.hasOwnProperty.call(message, "destId")) writer.uint32(/* id 7, wireType 2 =*/58).string(message.destId);
12490
+ if (message.body != null && Object.hasOwnProperty.call(message, "body")) writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.body);
12491
+ if (message.deviceCode != null && Object.hasOwnProperty.call(message, "deviceCode")) writer.uint32(/* id 9, wireType 2 =*/74).string(message.deviceCode);
12492
+ if (message.deviceType != null && Object.hasOwnProperty.call(message, "deviceType")) writer.uint32(/* id 12, wireType 0 =*/96).int32(message.deviceType);
12493
+ return writer;
12494
+ };
12489
12495
 
12490
- /**
12491
- * Decodes a NetworkRequest message from the specified reader or buffer.
12492
- * @function decode
12493
- * @memberof NetworkRequest
12494
- * @static
12495
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12496
- * @param {number} [length] Message length if known beforehand
12497
- * @returns {NetworkRequest} NetworkRequest
12498
- * @throws {Error} If the payload is not a reader or valid buffer
12499
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
12500
- */
12501
- NetworkRequest.decode = function decode(reader, length) {
12502
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
12503
- var end = length === undefined ? reader.len : reader.pos + length,
12504
- message = new $root.NetworkRequest();
12505
- while (reader.pos < end) {
12506
- var tag = reader.uint32();
12507
- switch (tag >>> 3) {
12508
- case 1:
12509
- {
12510
- message.cmdId = reader.int32();
12511
- break;
12512
- }
12513
- case 2:
12514
- {
12515
- message.messageSeq = reader.int64();
12516
- break;
12517
- }
12518
- case 3:
12519
- {
12520
- message.deviceId = reader.int64();
12521
- break;
12522
- }
12523
- case 4:
12524
- {
12525
- message.sessionId = reader.int64();
12526
- break;
12527
- }
12528
- case 5:
12529
- {
12530
- message.uid = reader.int64();
12531
- break;
12532
- }
12533
- case 6:
12534
- {
12535
- message.protocolVersion = reader.int32();
12536
- break;
12537
- }
12538
- case 7:
12539
- {
12540
- message.destId = reader.string();
12541
- break;
12542
- }
12543
- case 8:
12544
- {
12545
- message.body = reader.bytes();
12546
- break;
12547
- }
12548
- case 12:
12549
- {
12550
- message.deviceType = reader.int32();
12551
- break;
12552
- }
12553
- default:
12554
- reader.skipType(tag & 7);
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$2)) reader = $Reader$2.create(reader);
12509
+ let end = length === undefined ? reader.len : reader.pos + length,
12510
+ message = new $root$2.NetworkRequest();
12511
+ while (reader.pos < end) {
12512
+ let tag = reader.uint32();
12513
+ switch (tag >>> 3) {
12514
+ case 1:
12515
+ {
12516
+ message.cmdId = reader.int32();
12555
12517
  break;
12556
- }
12557
- }
12558
- return message;
12559
- };
12560
-
12561
- /**
12562
- * Gets the default type url for NetworkRequest
12563
- * @function getTypeUrl
12564
- * @memberof NetworkRequest
12565
- * @static
12566
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12567
- * @returns {string} The default type url
12568
- */
12569
- NetworkRequest.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12570
- if (typeUrlPrefix === undefined) {
12571
- typeUrlPrefix = "type.googleapis.com";
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 9:
12555
+ {
12556
+ message.deviceCode = reader.string();
12557
+ break;
12558
+ }
12559
+ case 12:
12560
+ {
12561
+ message.deviceType = reader.int32();
12562
+ break;
12563
+ }
12564
+ default:
12565
+ reader.skipType(tag & 7);
12566
+ break;
12572
12567
  }
12573
- return typeUrlPrefix + "/NetworkRequest";
12574
- };
12575
- return NetworkRequest;
12576
- }();
12577
- $root.NetworkResponse = function () {
12578
- /**
12579
- * Properties of a NetworkResponse.
12580
- * @exports INetworkResponse
12581
- * @interface INetworkResponse
12582
- * @property {number|null} [cmdId] NetworkResponse cmdId
12583
- * @property {Long|null} [messageSeq] NetworkResponse messageSeq
12584
- * @property {Long|null} [deviceId] NetworkResponse deviceId
12585
- * @property {Long|null} [uid] NetworkResponse uid
12586
- * @property {number|null} [protocolVersion] NetworkResponse protocolVersion
12587
- * @property {Uint8Array|null} [body] NetworkResponse body
12588
- * @property {number|null} [code] NetworkResponse code
12589
- */
12568
+ }
12569
+ return message;
12570
+ };
12590
12571
 
12591
- /**
12592
- * Constructs a new NetworkResponse.
12593
- * @exports NetworkResponse
12594
- * @classdesc Represents a NetworkResponse.
12595
- * @implements INetworkResponse
12596
- * @constructor
12597
- * @param {INetworkResponse=} [properties] Properties to set
12598
- */
12599
- function NetworkResponse(properties) {
12600
- 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]];
12572
+ /**
12573
+ * Gets the default type url for NetworkRequest
12574
+ * @function getTypeUrl
12575
+ * @memberof NetworkRequest
12576
+ * @static
12577
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12578
+ * @returns {string} The default type url
12579
+ */
12580
+ NetworkRequest.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12581
+ if (typeUrlPrefix === undefined) {
12582
+ typeUrlPrefix = "type.googleapis.com";
12601
12583
  }
12584
+ return typeUrlPrefix + "/NetworkRequest";
12585
+ };
12586
+ return NetworkRequest;
12587
+ })();
12588
+ const NetworkResponse = $root$2.NetworkResponse = (() => {
12589
+ /**
12590
+ * Properties of a NetworkResponse.
12591
+ * @exports INetworkResponse
12592
+ * @interface INetworkResponse
12593
+ * @property {number|null} [cmdId] NetworkResponse cmdId
12594
+ * @property {Long|null} [messageSeq] NetworkResponse messageSeq
12595
+ * @property {Long|null} [deviceId] NetworkResponse deviceId
12596
+ * @property {Long|null} [uid] NetworkResponse uid
12597
+ * @property {number|null} [protocolVersion] NetworkResponse protocolVersion
12598
+ * @property {Uint8Array|null} [body] NetworkResponse body
12599
+ * @property {number|null} [code] NetworkResponse code
12600
+ */
12602
12601
 
12603
- /**
12604
- * NetworkResponse cmdId.
12605
- * @member {number} cmdId
12606
- * @memberof NetworkResponse
12607
- * @instance
12608
- */
12609
- NetworkResponse.prototype.cmdId = 0;
12602
+ /**
12603
+ * Constructs a new NetworkResponse.
12604
+ * @exports NetworkResponse
12605
+ * @classdesc Represents a NetworkResponse.
12606
+ * @implements INetworkResponse
12607
+ * @constructor
12608
+ * @param {INetworkResponse=} [properties] Properties to set
12609
+ */
12610
+ function NetworkResponse(properties) {
12611
+ 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]];
12612
+ }
12610
12613
 
12611
- /**
12612
- * NetworkResponse messageSeq.
12613
- * @member {Long} messageSeq
12614
- * @memberof NetworkResponse
12615
- * @instance
12616
- */
12617
- NetworkResponse.prototype.messageSeq = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12614
+ /**
12615
+ * NetworkResponse cmdId.
12616
+ * @member {number} cmdId
12617
+ * @memberof NetworkResponse
12618
+ * @instance
12619
+ */
12620
+ NetworkResponse.prototype.cmdId = 0;
12618
12621
 
12619
- /**
12620
- * NetworkResponse deviceId.
12621
- * @member {Long} deviceId
12622
- * @memberof NetworkResponse
12623
- * @instance
12624
- */
12625
- NetworkResponse.prototype.deviceId = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12622
+ /**
12623
+ * NetworkResponse messageSeq.
12624
+ * @member {Long} messageSeq
12625
+ * @memberof NetworkResponse
12626
+ * @instance
12627
+ */
12628
+ NetworkResponse.prototype.messageSeq = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12626
12629
 
12627
- /**
12628
- * NetworkResponse uid.
12629
- * @member {Long} uid
12630
- * @memberof NetworkResponse
12631
- * @instance
12632
- */
12633
- NetworkResponse.prototype.uid = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12630
+ /**
12631
+ * NetworkResponse deviceId.
12632
+ * @member {Long} deviceId
12633
+ * @memberof NetworkResponse
12634
+ * @instance
12635
+ */
12636
+ NetworkResponse.prototype.deviceId = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12634
12637
 
12635
- /**
12636
- * NetworkResponse protocolVersion.
12637
- * @member {number} protocolVersion
12638
- * @memberof NetworkResponse
12639
- * @instance
12640
- */
12641
- NetworkResponse.prototype.protocolVersion = 0;
12638
+ /**
12639
+ * NetworkResponse uid.
12640
+ * @member {Long} uid
12641
+ * @memberof NetworkResponse
12642
+ * @instance
12643
+ */
12644
+ NetworkResponse.prototype.uid = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12642
12645
 
12643
- /**
12644
- * NetworkResponse body.
12645
- * @member {Uint8Array} body
12646
- * @memberof NetworkResponse
12647
- * @instance
12648
- */
12649
- NetworkResponse.prototype.body = $util.newBuffer([]);
12646
+ /**
12647
+ * NetworkResponse protocolVersion.
12648
+ * @member {number} protocolVersion
12649
+ * @memberof NetworkResponse
12650
+ * @instance
12651
+ */
12652
+ NetworkResponse.prototype.protocolVersion = 0;
12650
12653
 
12651
- /**
12652
- * NetworkResponse code.
12653
- * @member {number} code
12654
- * @memberof NetworkResponse
12655
- * @instance
12656
- */
12657
- NetworkResponse.prototype.code = 0;
12654
+ /**
12655
+ * NetworkResponse body.
12656
+ * @member {Uint8Array} body
12657
+ * @memberof NetworkResponse
12658
+ * @instance
12659
+ */
12660
+ NetworkResponse.prototype.body = $util$2.newBuffer([]);
12658
12661
 
12659
- /**
12660
- * Encodes the specified NetworkResponse message. Does not implicitly {@link NetworkResponse.verify|verify} messages.
12661
- * @function encode
12662
- * @memberof NetworkResponse
12663
- * @static
12664
- * @param {INetworkResponse} message NetworkResponse message or plain object to encode
12665
- * @param {$protobuf.Writer} [writer] Writer to encode to
12666
- * @returns {$protobuf.Writer} Writer
12667
- */
12668
- NetworkResponse.encode = function encode(message, writer) {
12669
- if (!writer) writer = $Writer.create();
12670
- if (message.cmdId != null && Object.hasOwnProperty.call(message, "cmdId")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.cmdId);
12671
- if (message.messageSeq != null && Object.hasOwnProperty.call(message, "messageSeq")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.messageSeq);
12672
- if (message.deviceId != null && Object.hasOwnProperty.call(message, "deviceId")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.deviceId);
12673
- if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) writer.uint32(/* id 5, wireType 0 =*/40).int64(message.uid);
12674
- if (message.protocolVersion != null && Object.hasOwnProperty.call(message, "protocolVersion")) writer.uint32(/* id 6, wireType 0 =*/48).int32(message.protocolVersion);
12675
- if (message.body != null && Object.hasOwnProperty.call(message, "body")) writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.body);
12676
- if (message.code != null && Object.hasOwnProperty.call(message, "code")) writer.uint32(/* id 9, wireType 0 =*/72).int32(message.code);
12677
- return writer;
12678
- };
12662
+ /**
12663
+ * NetworkResponse code.
12664
+ * @member {number} code
12665
+ * @memberof NetworkResponse
12666
+ * @instance
12667
+ */
12668
+ NetworkResponse.prototype.code = 0;
12679
12669
 
12680
- /**
12681
- * Decodes a NetworkResponse message from the specified reader or buffer.
12682
- * @function decode
12683
- * @memberof NetworkResponse
12684
- * @static
12685
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12686
- * @param {number} [length] Message length if known beforehand
12687
- * @returns {NetworkResponse} NetworkResponse
12688
- * @throws {Error} If the payload is not a reader or valid buffer
12689
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
12690
- */
12691
- NetworkResponse.decode = function decode(reader, length) {
12692
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
12693
- var end = length === undefined ? reader.len : reader.pos + length,
12694
- message = new $root.NetworkResponse();
12695
- while (reader.pos < end) {
12696
- var tag = reader.uint32();
12697
- switch (tag >>> 3) {
12698
- case 1:
12699
- {
12700
- message.cmdId = reader.int32();
12701
- break;
12702
- }
12703
- case 2:
12704
- {
12705
- message.messageSeq = reader.int64();
12706
- break;
12707
- }
12708
- case 3:
12709
- {
12710
- message.deviceId = reader.int64();
12711
- break;
12712
- }
12713
- case 5:
12714
- {
12715
- message.uid = reader.int64();
12716
- break;
12717
- }
12718
- case 6:
12719
- {
12720
- message.protocolVersion = reader.int32();
12721
- break;
12722
- }
12723
- case 8:
12724
- {
12725
- message.body = reader.bytes();
12726
- break;
12727
- }
12728
- case 9:
12729
- {
12730
- message.code = reader.int32();
12731
- break;
12732
- }
12733
- default:
12734
- reader.skipType(tag & 7);
12735
- break;
12736
- }
12737
- }
12738
- return message;
12739
- };
12670
+ /**
12671
+ * Encodes the specified NetworkResponse message. Does not implicitly {@link NetworkResponse.verify|verify} messages.
12672
+ * @function encode
12673
+ * @memberof NetworkResponse
12674
+ * @static
12675
+ * @param {INetworkResponse} message NetworkResponse message or plain object to encode
12676
+ * @param {$protobuf.Writer} [writer] Writer to encode to
12677
+ * @returns {$protobuf.Writer} Writer
12678
+ */
12679
+ NetworkResponse.encode = function encode(message, writer) {
12680
+ if (!writer) writer = $Writer$2.create();
12681
+ if (message.cmdId != null && Object.hasOwnProperty.call(message, "cmdId")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.cmdId);
12682
+ if (message.messageSeq != null && Object.hasOwnProperty.call(message, "messageSeq")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.messageSeq);
12683
+ if (message.deviceId != null && Object.hasOwnProperty.call(message, "deviceId")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.deviceId);
12684
+ if (message.uid != null && Object.hasOwnProperty.call(message, "uid")) writer.uint32(/* id 5, wireType 0 =*/40).int64(message.uid);
12685
+ if (message.protocolVersion != null && Object.hasOwnProperty.call(message, "protocolVersion")) writer.uint32(/* id 6, wireType 0 =*/48).int32(message.protocolVersion);
12686
+ if (message.body != null && Object.hasOwnProperty.call(message, "body")) writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.body);
12687
+ if (message.code != null && Object.hasOwnProperty.call(message, "code")) writer.uint32(/* id 9, wireType 0 =*/72).int32(message.code);
12688
+ return writer;
12689
+ };
12740
12690
 
12741
- /**
12742
- * Gets the default type url for NetworkResponse
12743
- * @function getTypeUrl
12744
- * @memberof NetworkResponse
12745
- * @static
12746
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12747
- * @returns {string} The default type url
12748
- */
12749
- NetworkResponse.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12750
- if (typeUrlPrefix === undefined) {
12751
- typeUrlPrefix = "type.googleapis.com";
12691
+ /**
12692
+ * Decodes a NetworkResponse message from the specified reader or buffer.
12693
+ * @function decode
12694
+ * @memberof NetworkResponse
12695
+ * @static
12696
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12697
+ * @param {number} [length] Message length if known beforehand
12698
+ * @returns {NetworkResponse} NetworkResponse
12699
+ * @throws {Error} If the payload is not a reader or valid buffer
12700
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
12701
+ */
12702
+ NetworkResponse.decode = function decode(reader, length) {
12703
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
12704
+ let end = length === undefined ? reader.len : reader.pos + length,
12705
+ message = new $root$2.NetworkResponse();
12706
+ while (reader.pos < end) {
12707
+ let tag = reader.uint32();
12708
+ switch (tag >>> 3) {
12709
+ case 1:
12710
+ {
12711
+ message.cmdId = reader.int32();
12712
+ break;
12713
+ }
12714
+ case 2:
12715
+ {
12716
+ message.messageSeq = reader.int64();
12717
+ break;
12718
+ }
12719
+ case 3:
12720
+ {
12721
+ message.deviceId = reader.int64();
12722
+ break;
12723
+ }
12724
+ case 5:
12725
+ {
12726
+ message.uid = reader.int64();
12727
+ break;
12728
+ }
12729
+ case 6:
12730
+ {
12731
+ message.protocolVersion = reader.int32();
12732
+ break;
12733
+ }
12734
+ case 8:
12735
+ {
12736
+ message.body = reader.bytes();
12737
+ break;
12738
+ }
12739
+ case 9:
12740
+ {
12741
+ message.code = reader.int32();
12742
+ break;
12743
+ }
12744
+ default:
12745
+ reader.skipType(tag & 7);
12746
+ break;
12752
12747
  }
12753
- return typeUrlPrefix + "/NetworkResponse";
12754
- };
12755
- return NetworkResponse;
12756
- }();
12757
- $root.HeartbeatReq = function () {
12758
- /**
12759
- * Properties of a HeartbeatReq.
12760
- * @exports IHeartbeatReq
12761
- * @interface IHeartbeatReq
12762
- * @property {Long|null} [pingId] HeartbeatReq pingId
12763
- * @property {Long|null} [disconnectDelay] HeartbeatReq disconnectDelay
12764
- */
12765
-
12766
- /**
12767
- * Constructs a new HeartbeatReq.
12768
- * @exports HeartbeatReq
12769
- * @classdesc Represents a HeartbeatReq.
12770
- * @implements IHeartbeatReq
12771
- * @constructor
12772
- * @param {IHeartbeatReq=} [properties] Properties to set
12773
- */
12774
- function HeartbeatReq(properties) {
12775
- 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]];
12776
12748
  }
12749
+ return message;
12750
+ };
12777
12751
 
12778
- /**
12779
- * HeartbeatReq pingId.
12780
- * @member {Long} pingId
12781
- * @memberof HeartbeatReq
12782
- * @instance
12783
- */
12784
- HeartbeatReq.prototype.pingId = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12785
-
12786
- /**
12787
- * HeartbeatReq disconnectDelay.
12788
- * @member {Long} disconnectDelay
12789
- * @memberof HeartbeatReq
12790
- * @instance
12791
- */
12792
- HeartbeatReq.prototype.disconnectDelay = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12793
-
12794
- /**
12795
- * Encodes the specified HeartbeatReq message. Does not implicitly {@link HeartbeatReq.verify|verify} messages.
12796
- * @function encode
12797
- * @memberof HeartbeatReq
12798
- * @static
12799
- * @param {IHeartbeatReq} message HeartbeatReq message or plain object to encode
12800
- * @param {$protobuf.Writer} [writer] Writer to encode to
12801
- * @returns {$protobuf.Writer} Writer
12802
- */
12803
- HeartbeatReq.encode = function encode(message, writer) {
12804
- if (!writer) writer = $Writer.create();
12805
- if (message.pingId != null && Object.hasOwnProperty.call(message, "pingId")) writer.uint32(/* id 1, wireType 0 =*/8).int64(message.pingId);
12806
- if (message.disconnectDelay != null && Object.hasOwnProperty.call(message, "disconnectDelay")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.disconnectDelay);
12807
- return writer;
12808
- };
12752
+ /**
12753
+ * Gets the default type url for NetworkResponse
12754
+ * @function getTypeUrl
12755
+ * @memberof NetworkResponse
12756
+ * @static
12757
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12758
+ * @returns {string} The default type url
12759
+ */
12760
+ NetworkResponse.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12761
+ if (typeUrlPrefix === undefined) {
12762
+ typeUrlPrefix = "type.googleapis.com";
12763
+ }
12764
+ return typeUrlPrefix + "/NetworkResponse";
12765
+ };
12766
+ return NetworkResponse;
12767
+ })();
12768
+ const HeartbeatReq = $root$2.HeartbeatReq = (() => {
12769
+ /**
12770
+ * Properties of a HeartbeatReq.
12771
+ * @exports IHeartbeatReq
12772
+ * @interface IHeartbeatReq
12773
+ * @property {Long|null} [pingId] HeartbeatReq pingId
12774
+ * @property {Long|null} [disconnectDelay] HeartbeatReq disconnectDelay
12775
+ */
12809
12776
 
12810
- /**
12811
- * Decodes a HeartbeatReq message from the specified reader or buffer.
12812
- * @function decode
12813
- * @memberof HeartbeatReq
12814
- * @static
12815
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12816
- * @param {number} [length] Message length if known beforehand
12817
- * @returns {HeartbeatReq} HeartbeatReq
12818
- * @throws {Error} If the payload is not a reader or valid buffer
12819
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
12820
- */
12821
- HeartbeatReq.decode = function decode(reader, length) {
12822
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
12823
- var end = length === undefined ? reader.len : reader.pos + length,
12824
- message = new $root.HeartbeatReq();
12825
- while (reader.pos < end) {
12826
- var tag = reader.uint32();
12827
- switch (tag >>> 3) {
12828
- case 1:
12829
- {
12830
- message.pingId = reader.int64();
12831
- break;
12832
- }
12833
- case 2:
12834
- {
12835
- message.disconnectDelay = reader.int64();
12836
- break;
12837
- }
12838
- default:
12839
- reader.skipType(tag & 7);
12840
- break;
12841
- }
12842
- }
12843
- return message;
12844
- };
12777
+ /**
12778
+ * Constructs a new HeartbeatReq.
12779
+ * @exports HeartbeatReq
12780
+ * @classdesc Represents a HeartbeatReq.
12781
+ * @implements IHeartbeatReq
12782
+ * @constructor
12783
+ * @param {IHeartbeatReq=} [properties] Properties to set
12784
+ */
12785
+ function HeartbeatReq(properties) {
12786
+ 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]];
12787
+ }
12845
12788
 
12846
- /**
12847
- * Gets the default type url for HeartbeatReq
12848
- * @function getTypeUrl
12849
- * @memberof HeartbeatReq
12850
- * @static
12851
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12852
- * @returns {string} The default type url
12853
- */
12854
- HeartbeatReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12855
- if (typeUrlPrefix === undefined) {
12856
- typeUrlPrefix = "type.googleapis.com";
12857
- }
12858
- return typeUrlPrefix + "/HeartbeatReq";
12859
- };
12860
- return HeartbeatReq;
12861
- }();
12862
- $root.SystemCurrentTimeMillisReq = function () {
12863
- /**
12864
- * Properties of a SystemCurrentTimeMillisReq.
12865
- * @exports ISystemCurrentTimeMillisReq
12866
- * @interface ISystemCurrentTimeMillisReq
12867
- */
12789
+ /**
12790
+ * HeartbeatReq pingId.
12791
+ * @member {Long} pingId
12792
+ * @memberof HeartbeatReq
12793
+ * @instance
12794
+ */
12795
+ HeartbeatReq.prototype.pingId = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12868
12796
 
12869
- /**
12870
- * Constructs a new SystemCurrentTimeMillisReq.
12871
- * @exports SystemCurrentTimeMillisReq
12872
- * @classdesc Represents a SystemCurrentTimeMillisReq.
12873
- * @implements ISystemCurrentTimeMillisReq
12874
- * @constructor
12875
- * @param {ISystemCurrentTimeMillisReq=} [properties] Properties to set
12876
- */
12877
- function SystemCurrentTimeMillisReq(properties) {
12878
- 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]];
12879
- }
12797
+ /**
12798
+ * HeartbeatReq disconnectDelay.
12799
+ * @member {Long} disconnectDelay
12800
+ * @memberof HeartbeatReq
12801
+ * @instance
12802
+ */
12803
+ HeartbeatReq.prototype.disconnectDelay = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12880
12804
 
12881
- /**
12882
- * Encodes the specified SystemCurrentTimeMillisReq message. Does not implicitly {@link SystemCurrentTimeMillisReq.verify|verify} messages.
12883
- * @function encode
12884
- * @memberof SystemCurrentTimeMillisReq
12885
- * @static
12886
- * @param {ISystemCurrentTimeMillisReq} message SystemCurrentTimeMillisReq message or plain object to encode
12887
- * @param {$protobuf.Writer} [writer] Writer to encode to
12888
- * @returns {$protobuf.Writer} Writer
12889
- */
12890
- SystemCurrentTimeMillisReq.encode = function encode(message, writer) {
12891
- if (!writer) writer = $Writer.create();
12892
- return writer;
12893
- };
12805
+ /**
12806
+ * Encodes the specified HeartbeatReq message. Does not implicitly {@link HeartbeatReq.verify|verify} messages.
12807
+ * @function encode
12808
+ * @memberof HeartbeatReq
12809
+ * @static
12810
+ * @param {IHeartbeatReq} message HeartbeatReq message or plain object to encode
12811
+ * @param {$protobuf.Writer} [writer] Writer to encode to
12812
+ * @returns {$protobuf.Writer} Writer
12813
+ */
12814
+ HeartbeatReq.encode = function encode(message, writer) {
12815
+ if (!writer) writer = $Writer$2.create();
12816
+ if (message.pingId != null && Object.hasOwnProperty.call(message, "pingId")) writer.uint32(/* id 1, wireType 0 =*/8).int64(message.pingId);
12817
+ if (message.disconnectDelay != null && Object.hasOwnProperty.call(message, "disconnectDelay")) writer.uint32(/* id 2, wireType 0 =*/16).int64(message.disconnectDelay);
12818
+ return writer;
12819
+ };
12894
12820
 
12895
- /**
12896
- * Decodes a SystemCurrentTimeMillisReq message from the specified reader or buffer.
12897
- * @function decode
12898
- * @memberof SystemCurrentTimeMillisReq
12899
- * @static
12900
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12901
- * @param {number} [length] Message length if known beforehand
12902
- * @returns {SystemCurrentTimeMillisReq} SystemCurrentTimeMillisReq
12903
- * @throws {Error} If the payload is not a reader or valid buffer
12904
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
12905
- */
12906
- SystemCurrentTimeMillisReq.decode = function decode(reader, length) {
12907
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
12908
- var end = length === undefined ? reader.len : reader.pos + length,
12909
- message = new $root.SystemCurrentTimeMillisReq();
12910
- while (reader.pos < end) {
12911
- var tag = reader.uint32();
12912
- switch (tag >>> 3) {
12913
- default:
12914
- reader.skipType(tag & 7);
12821
+ /**
12822
+ * Decodes a HeartbeatReq message from the specified reader or buffer.
12823
+ * @function decode
12824
+ * @memberof HeartbeatReq
12825
+ * @static
12826
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12827
+ * @param {number} [length] Message length if known beforehand
12828
+ * @returns {HeartbeatReq} HeartbeatReq
12829
+ * @throws {Error} If the payload is not a reader or valid buffer
12830
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
12831
+ */
12832
+ HeartbeatReq.decode = function decode(reader, length) {
12833
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
12834
+ let end = length === undefined ? reader.len : reader.pos + length,
12835
+ message = new $root$2.HeartbeatReq();
12836
+ while (reader.pos < end) {
12837
+ let tag = reader.uint32();
12838
+ switch (tag >>> 3) {
12839
+ case 1:
12840
+ {
12841
+ message.pingId = reader.int64();
12915
12842
  break;
12916
- }
12917
- }
12918
- return message;
12919
- };
12920
-
12921
- /**
12922
- * Gets the default type url for SystemCurrentTimeMillisReq
12923
- * @function getTypeUrl
12924
- * @memberof SystemCurrentTimeMillisReq
12925
- * @static
12926
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12927
- * @returns {string} The default type url
12928
- */
12929
- SystemCurrentTimeMillisReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12930
- if (typeUrlPrefix === undefined) {
12931
- typeUrlPrefix = "type.googleapis.com";
12843
+ }
12844
+ case 2:
12845
+ {
12846
+ message.disconnectDelay = reader.int64();
12847
+ break;
12848
+ }
12849
+ default:
12850
+ reader.skipType(tag & 7);
12851
+ break;
12932
12852
  }
12933
- return typeUrlPrefix + "/SystemCurrentTimeMillisReq";
12934
- };
12935
- return SystemCurrentTimeMillisReq;
12936
- }();
12937
- $root.SystemCurrentTimeMillisResp = function () {
12938
- /**
12939
- * Properties of a SystemCurrentTimeMillisResp.
12940
- * @exports ISystemCurrentTimeMillisResp
12941
- * @interface ISystemCurrentTimeMillisResp
12942
- * @property {number|null} [errorCode] SystemCurrentTimeMillisResp errorCode
12943
- * @property {string|null} [errorMessage] SystemCurrentTimeMillisResp errorMessage
12944
- * @property {Long|null} [currentTimeMillis] SystemCurrentTimeMillisResp currentTimeMillis
12945
- */
12946
-
12947
- /**
12948
- * Constructs a new SystemCurrentTimeMillisResp.
12949
- * @exports SystemCurrentTimeMillisResp
12950
- * @classdesc Represents a SystemCurrentTimeMillisResp.
12951
- * @implements ISystemCurrentTimeMillisResp
12952
- * @constructor
12953
- * @param {ISystemCurrentTimeMillisResp=} [properties] Properties to set
12954
- */
12955
- function SystemCurrentTimeMillisResp(properties) {
12956
- 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]];
12957
12853
  }
12854
+ return message;
12855
+ };
12958
12856
 
12959
- /**
12960
- * SystemCurrentTimeMillisResp errorCode.
12961
- * @member {number} errorCode
12962
- * @memberof SystemCurrentTimeMillisResp
12963
- * @instance
12964
- */
12965
- SystemCurrentTimeMillisResp.prototype.errorCode = 0;
12966
-
12967
- /**
12968
- * SystemCurrentTimeMillisResp errorMessage.
12969
- * @member {string} errorMessage
12970
- * @memberof SystemCurrentTimeMillisResp
12971
- * @instance
12972
- */
12973
- SystemCurrentTimeMillisResp.prototype.errorMessage = "";
12974
-
12975
- /**
12976
- * SystemCurrentTimeMillisResp currentTimeMillis.
12977
- * @member {Long} currentTimeMillis
12978
- * @memberof SystemCurrentTimeMillisResp
12979
- * @instance
12980
- */
12981
- SystemCurrentTimeMillisResp.prototype.currentTimeMillis = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
12857
+ /**
12858
+ * Gets the default type url for HeartbeatReq
12859
+ * @function getTypeUrl
12860
+ * @memberof HeartbeatReq
12861
+ * @static
12862
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12863
+ * @returns {string} The default type url
12864
+ */
12865
+ HeartbeatReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12866
+ if (typeUrlPrefix === undefined) {
12867
+ typeUrlPrefix = "type.googleapis.com";
12868
+ }
12869
+ return typeUrlPrefix + "/HeartbeatReq";
12870
+ };
12871
+ return HeartbeatReq;
12872
+ })();
12873
+ $root$2.SystemCurrentTimeMillisReq = (() => {
12874
+ /**
12875
+ * Properties of a SystemCurrentTimeMillisReq.
12876
+ * @exports ISystemCurrentTimeMillisReq
12877
+ * @interface ISystemCurrentTimeMillisReq
12878
+ */
12982
12879
 
12983
- /**
12984
- * Encodes the specified SystemCurrentTimeMillisResp message. Does not implicitly {@link SystemCurrentTimeMillisResp.verify|verify} messages.
12985
- * @function encode
12986
- * @memberof SystemCurrentTimeMillisResp
12987
- * @static
12988
- * @param {ISystemCurrentTimeMillisResp} message SystemCurrentTimeMillisResp message or plain object to encode
12989
- * @param {$protobuf.Writer} [writer] Writer to encode to
12990
- * @returns {$protobuf.Writer} Writer
12991
- */
12992
- SystemCurrentTimeMillisResp.encode = function encode(message, writer) {
12993
- if (!writer) writer = $Writer.create();
12994
- if (message.errorCode != null && Object.hasOwnProperty.call(message, "errorCode")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.errorCode);
12995
- if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
12996
- if (message.currentTimeMillis != null && Object.hasOwnProperty.call(message, "currentTimeMillis")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.currentTimeMillis);
12997
- return writer;
12998
- };
12880
+ /**
12881
+ * Constructs a new SystemCurrentTimeMillisReq.
12882
+ * @exports SystemCurrentTimeMillisReq
12883
+ * @classdesc Represents a SystemCurrentTimeMillisReq.
12884
+ * @implements ISystemCurrentTimeMillisReq
12885
+ * @constructor
12886
+ * @param {ISystemCurrentTimeMillisReq=} [properties] Properties to set
12887
+ */
12888
+ function SystemCurrentTimeMillisReq(properties) {
12889
+ 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]];
12890
+ }
12999
12891
 
13000
- /**
13001
- * Decodes a SystemCurrentTimeMillisResp message from the specified reader or buffer.
13002
- * @function decode
13003
- * @memberof SystemCurrentTimeMillisResp
13004
- * @static
13005
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
13006
- * @param {number} [length] Message length if known beforehand
13007
- * @returns {SystemCurrentTimeMillisResp} SystemCurrentTimeMillisResp
13008
- * @throws {Error} If the payload is not a reader or valid buffer
13009
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
13010
- */
13011
- SystemCurrentTimeMillisResp.decode = function decode(reader, length) {
13012
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
13013
- var end = length === undefined ? reader.len : reader.pos + length,
13014
- message = new $root.SystemCurrentTimeMillisResp();
13015
- while (reader.pos < end) {
13016
- var tag = reader.uint32();
13017
- switch (tag >>> 3) {
13018
- case 1:
13019
- {
13020
- message.errorCode = reader.int32();
13021
- break;
13022
- }
13023
- case 2:
13024
- {
13025
- message.errorMessage = reader.string();
13026
- break;
13027
- }
13028
- case 3:
13029
- {
13030
- message.currentTimeMillis = reader.int64();
13031
- break;
13032
- }
13033
- default:
13034
- reader.skipType(tag & 7);
13035
- break;
13036
- }
13037
- }
13038
- return message;
13039
- };
12892
+ /**
12893
+ * Encodes the specified SystemCurrentTimeMillisReq message. Does not implicitly {@link SystemCurrentTimeMillisReq.verify|verify} messages.
12894
+ * @function encode
12895
+ * @memberof SystemCurrentTimeMillisReq
12896
+ * @static
12897
+ * @param {ISystemCurrentTimeMillisReq} message SystemCurrentTimeMillisReq message or plain object to encode
12898
+ * @param {$protobuf.Writer} [writer] Writer to encode to
12899
+ * @returns {$protobuf.Writer} Writer
12900
+ */
12901
+ SystemCurrentTimeMillisReq.encode = function encode(message, writer) {
12902
+ if (!writer) writer = $Writer$2.create();
12903
+ return writer;
12904
+ };
13040
12905
 
13041
- /**
13042
- * Gets the default type url for SystemCurrentTimeMillisResp
13043
- * @function getTypeUrl
13044
- * @memberof SystemCurrentTimeMillisResp
13045
- * @static
13046
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
13047
- * @returns {string} The default type url
13048
- */
13049
- SystemCurrentTimeMillisResp.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
13050
- if (typeUrlPrefix === undefined) {
13051
- typeUrlPrefix = "type.googleapis.com";
12906
+ /**
12907
+ * Decodes a SystemCurrentTimeMillisReq message from the specified reader or buffer.
12908
+ * @function decode
12909
+ * @memberof SystemCurrentTimeMillisReq
12910
+ * @static
12911
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
12912
+ * @param {number} [length] Message length if known beforehand
12913
+ * @returns {SystemCurrentTimeMillisReq} SystemCurrentTimeMillisReq
12914
+ * @throws {Error} If the payload is not a reader or valid buffer
12915
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
12916
+ */
12917
+ SystemCurrentTimeMillisReq.decode = function decode(reader, length) {
12918
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
12919
+ let end = length === undefined ? reader.len : reader.pos + length,
12920
+ message = new $root$2.SystemCurrentTimeMillisReq();
12921
+ while (reader.pos < end) {
12922
+ let tag = reader.uint32();
12923
+ switch (tag >>> 3) {
12924
+ default:
12925
+ reader.skipType(tag & 7);
12926
+ break;
13052
12927
  }
13053
- return typeUrlPrefix + "/SystemCurrentTimeMillisResp";
13054
- };
13055
- return SystemCurrentTimeMillisResp;
13056
- }();
13057
- $root.BaseResp = function () {
13058
- /**
13059
- * Properties of a BaseResp.
13060
- * @exports IBaseResp
13061
- * @interface IBaseResp
13062
- * @property {number|null} [errorCode] BaseResp errorCode
13063
- * @property {string|null} [errorMessage] BaseResp errorMessage
13064
- */
12928
+ }
12929
+ return message;
12930
+ };
13065
12931
 
13066
- /**
13067
- * Constructs a new BaseResp.
13068
- * @exports BaseResp
13069
- * @classdesc Represents a BaseResp.
13070
- * @implements IBaseResp
13071
- * @constructor
13072
- * @param {IBaseResp=} [properties] Properties to set
13073
- */
13074
- function BaseResp(properties) {
13075
- 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]];
12932
+ /**
12933
+ * Gets the default type url for SystemCurrentTimeMillisReq
12934
+ * @function getTypeUrl
12935
+ * @memberof SystemCurrentTimeMillisReq
12936
+ * @static
12937
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
12938
+ * @returns {string} The default type url
12939
+ */
12940
+ SystemCurrentTimeMillisReq.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
12941
+ if (typeUrlPrefix === undefined) {
12942
+ typeUrlPrefix = "type.googleapis.com";
13076
12943
  }
12944
+ return typeUrlPrefix + "/SystemCurrentTimeMillisReq";
12945
+ };
12946
+ return SystemCurrentTimeMillisReq;
12947
+ })();
12948
+ const SystemCurrentTimeMillisResp = $root$2.SystemCurrentTimeMillisResp = (() => {
12949
+ /**
12950
+ * Properties of a SystemCurrentTimeMillisResp.
12951
+ * @exports ISystemCurrentTimeMillisResp
12952
+ * @interface ISystemCurrentTimeMillisResp
12953
+ * @property {number|null} [errorCode] SystemCurrentTimeMillisResp errorCode
12954
+ * @property {string|null} [errorMessage] SystemCurrentTimeMillisResp errorMessage
12955
+ * @property {Long|null} [currentTimeMillis] SystemCurrentTimeMillisResp currentTimeMillis
12956
+ */
13077
12957
 
13078
- /**
13079
- * BaseResp errorCode.
13080
- * @member {number} errorCode
13081
- * @memberof BaseResp
13082
- * @instance
13083
- */
13084
- BaseResp.prototype.errorCode = 0;
12958
+ /**
12959
+ * Constructs a new SystemCurrentTimeMillisResp.
12960
+ * @exports SystemCurrentTimeMillisResp
12961
+ * @classdesc Represents a SystemCurrentTimeMillisResp.
12962
+ * @implements ISystemCurrentTimeMillisResp
12963
+ * @constructor
12964
+ * @param {ISystemCurrentTimeMillisResp=} [properties] Properties to set
12965
+ */
12966
+ function SystemCurrentTimeMillisResp(properties) {
12967
+ 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]];
12968
+ }
13085
12969
 
13086
- /**
13087
- * BaseResp errorMessage.
13088
- * @member {string} errorMessage
13089
- * @memberof BaseResp
13090
- * @instance
13091
- */
13092
- BaseResp.prototype.errorMessage = "";
12970
+ /**
12971
+ * SystemCurrentTimeMillisResp errorCode.
12972
+ * @member {number} errorCode
12973
+ * @memberof SystemCurrentTimeMillisResp
12974
+ * @instance
12975
+ */
12976
+ SystemCurrentTimeMillisResp.prototype.errorCode = 0;
13093
12977
 
13094
- /**
13095
- * Encodes the specified BaseResp message. Does not implicitly {@link BaseResp.verify|verify} messages.
13096
- * @function encode
13097
- * @memberof BaseResp
13098
- * @static
13099
- * @param {IBaseResp} message BaseResp message or plain object to encode
13100
- * @param {$protobuf.Writer} [writer] Writer to encode to
13101
- * @returns {$protobuf.Writer} Writer
13102
- */
13103
- BaseResp.encode = function encode(message, writer) {
13104
- if (!writer) writer = $Writer.create();
13105
- if (message.errorCode != null && Object.hasOwnProperty.call(message, "errorCode")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.errorCode);
13106
- if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
13107
- return writer;
13108
- };
12978
+ /**
12979
+ * SystemCurrentTimeMillisResp errorMessage.
12980
+ * @member {string} errorMessage
12981
+ * @memberof SystemCurrentTimeMillisResp
12982
+ * @instance
12983
+ */
12984
+ SystemCurrentTimeMillisResp.prototype.errorMessage = "";
13109
12985
 
13110
- /**
13111
- * Decodes a BaseResp message from the specified reader or buffer.
13112
- * @function decode
13113
- * @memberof BaseResp
13114
- * @static
13115
- * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
13116
- * @param {number} [length] Message length if known beforehand
13117
- * @returns {BaseResp} BaseResp
13118
- * @throws {Error} If the payload is not a reader or valid buffer
13119
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
13120
- */
13121
- BaseResp.decode = function decode(reader, length) {
13122
- if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
13123
- var end = length === undefined ? reader.len : reader.pos + length,
13124
- message = new $root.BaseResp();
13125
- while (reader.pos < end) {
13126
- var tag = reader.uint32();
13127
- switch (tag >>> 3) {
13128
- case 1:
13129
- {
13130
- message.errorCode = reader.int32();
13131
- break;
13132
- }
13133
- case 2:
13134
- {
13135
- message.errorMessage = reader.string();
13136
- break;
13137
- }
13138
- default:
13139
- reader.skipType(tag & 7);
12986
+ /**
12987
+ * SystemCurrentTimeMillisResp currentTimeMillis.
12988
+ * @member {Long} currentTimeMillis
12989
+ * @memberof SystemCurrentTimeMillisResp
12990
+ * @instance
12991
+ */
12992
+ SystemCurrentTimeMillisResp.prototype.currentTimeMillis = $util$2.Long ? $util$2.Long.fromBits(0, 0, false) : 0;
12993
+
12994
+ /**
12995
+ * Encodes the specified SystemCurrentTimeMillisResp message. Does not implicitly {@link SystemCurrentTimeMillisResp.verify|verify} messages.
12996
+ * @function encode
12997
+ * @memberof SystemCurrentTimeMillisResp
12998
+ * @static
12999
+ * @param {ISystemCurrentTimeMillisResp} message SystemCurrentTimeMillisResp message or plain object to encode
13000
+ * @param {$protobuf.Writer} [writer] Writer to encode to
13001
+ * @returns {$protobuf.Writer} Writer
13002
+ */
13003
+ SystemCurrentTimeMillisResp.encode = function encode(message, writer) {
13004
+ if (!writer) writer = $Writer$2.create();
13005
+ if (message.errorCode != null && Object.hasOwnProperty.call(message, "errorCode")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.errorCode);
13006
+ if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
13007
+ if (message.currentTimeMillis != null && Object.hasOwnProperty.call(message, "currentTimeMillis")) writer.uint32(/* id 3, wireType 0 =*/24).int64(message.currentTimeMillis);
13008
+ return writer;
13009
+ };
13010
+
13011
+ /**
13012
+ * Decodes a SystemCurrentTimeMillisResp message from the specified reader or buffer.
13013
+ * @function decode
13014
+ * @memberof SystemCurrentTimeMillisResp
13015
+ * @static
13016
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
13017
+ * @param {number} [length] Message length if known beforehand
13018
+ * @returns {SystemCurrentTimeMillisResp} SystemCurrentTimeMillisResp
13019
+ * @throws {Error} If the payload is not a reader or valid buffer
13020
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
13021
+ */
13022
+ SystemCurrentTimeMillisResp.decode = function decode(reader, length) {
13023
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
13024
+ let end = length === undefined ? reader.len : reader.pos + length,
13025
+ message = new $root$2.SystemCurrentTimeMillisResp();
13026
+ while (reader.pos < end) {
13027
+ let tag = reader.uint32();
13028
+ switch (tag >>> 3) {
13029
+ case 1:
13030
+ {
13031
+ message.errorCode = reader.int32();
13140
13032
  break;
13141
- }
13033
+ }
13034
+ case 2:
13035
+ {
13036
+ message.errorMessage = reader.string();
13037
+ break;
13038
+ }
13039
+ case 3:
13040
+ {
13041
+ message.currentTimeMillis = reader.int64();
13042
+ break;
13043
+ }
13044
+ default:
13045
+ reader.skipType(tag & 7);
13046
+ break;
13142
13047
  }
13143
- return message;
13144
- };
13048
+ }
13049
+ return message;
13050
+ };
13145
13051
 
13146
- /**
13147
- * Gets the default type url for BaseResp
13148
- * @function getTypeUrl
13149
- * @memberof BaseResp
13150
- * @static
13151
- * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
13152
- * @returns {string} The default type url
13153
- */
13154
- BaseResp.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
13155
- if (typeUrlPrefix === undefined) {
13156
- typeUrlPrefix = "type.googleapis.com";
13052
+ /**
13053
+ * Gets the default type url for SystemCurrentTimeMillisResp
13054
+ * @function getTypeUrl
13055
+ * @memberof SystemCurrentTimeMillisResp
13056
+ * @static
13057
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
13058
+ * @returns {string} The default type url
13059
+ */
13060
+ SystemCurrentTimeMillisResp.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
13061
+ if (typeUrlPrefix === undefined) {
13062
+ typeUrlPrefix = "type.googleapis.com";
13063
+ }
13064
+ return typeUrlPrefix + "/SystemCurrentTimeMillisResp";
13065
+ };
13066
+ return SystemCurrentTimeMillisResp;
13067
+ })();
13068
+ const BaseResp = $root$2.BaseResp = (() => {
13069
+ /**
13070
+ * Properties of a BaseResp.
13071
+ * @exports IBaseResp
13072
+ * @interface IBaseResp
13073
+ * @property {number|null} [errorCode] BaseResp errorCode
13074
+ * @property {string|null} [errorMessage] BaseResp errorMessage
13075
+ */
13076
+
13077
+ /**
13078
+ * Constructs a new BaseResp.
13079
+ * @exports BaseResp
13080
+ * @classdesc Represents a BaseResp.
13081
+ * @implements IBaseResp
13082
+ * @constructor
13083
+ * @param {IBaseResp=} [properties] Properties to set
13084
+ */
13085
+ function BaseResp(properties) {
13086
+ 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]];
13087
+ }
13088
+
13089
+ /**
13090
+ * BaseResp errorCode.
13091
+ * @member {number} errorCode
13092
+ * @memberof BaseResp
13093
+ * @instance
13094
+ */
13095
+ BaseResp.prototype.errorCode = 0;
13096
+
13097
+ /**
13098
+ * BaseResp errorMessage.
13099
+ * @member {string} errorMessage
13100
+ * @memberof BaseResp
13101
+ * @instance
13102
+ */
13103
+ BaseResp.prototype.errorMessage = "";
13104
+
13105
+ /**
13106
+ * Encodes the specified BaseResp message. Does not implicitly {@link BaseResp.verify|verify} messages.
13107
+ * @function encode
13108
+ * @memberof BaseResp
13109
+ * @static
13110
+ * @param {IBaseResp} message BaseResp message or plain object to encode
13111
+ * @param {$protobuf.Writer} [writer] Writer to encode to
13112
+ * @returns {$protobuf.Writer} Writer
13113
+ */
13114
+ BaseResp.encode = function encode(message, writer) {
13115
+ if (!writer) writer = $Writer$2.create();
13116
+ if (message.errorCode != null && Object.hasOwnProperty.call(message, "errorCode")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.errorCode);
13117
+ if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.errorMessage);
13118
+ return writer;
13119
+ };
13120
+
13121
+ /**
13122
+ * Decodes a BaseResp message from the specified reader or buffer.
13123
+ * @function decode
13124
+ * @memberof BaseResp
13125
+ * @static
13126
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
13127
+ * @param {number} [length] Message length if known beforehand
13128
+ * @returns {BaseResp} BaseResp
13129
+ * @throws {Error} If the payload is not a reader or valid buffer
13130
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
13131
+ */
13132
+ BaseResp.decode = function decode(reader, length) {
13133
+ if (!(reader instanceof $Reader$2)) reader = $Reader$2.create(reader);
13134
+ let end = length === undefined ? reader.len : reader.pos + length,
13135
+ message = new $root$2.BaseResp();
13136
+ while (reader.pos < end) {
13137
+ let tag = reader.uint32();
13138
+ switch (tag >>> 3) {
13139
+ case 1:
13140
+ {
13141
+ message.errorCode = reader.int32();
13142
+ break;
13143
+ }
13144
+ case 2:
13145
+ {
13146
+ message.errorMessage = reader.string();
13147
+ break;
13148
+ }
13149
+ default:
13150
+ reader.skipType(tag & 7);
13151
+ break;
13157
13152
  }
13158
- return typeUrlPrefix + "/BaseResp";
13159
- };
13160
- return BaseResp;
13161
- }();
13162
- rpc_base = $root;
13163
- return rpc_base;
13164
- }
13153
+ }
13154
+ return message;
13155
+ };
13165
13156
 
13166
- var rpc_baseExports = requireRpc_base();
13157
+ /**
13158
+ * Gets the default type url for BaseResp
13159
+ * @function getTypeUrl
13160
+ * @memberof BaseResp
13161
+ * @static
13162
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
13163
+ * @returns {string} The default type url
13164
+ */
13165
+ BaseResp.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
13166
+ if (typeUrlPrefix === undefined) {
13167
+ typeUrlPrefix = "type.googleapis.com";
13168
+ }
13169
+ return typeUrlPrefix + "/BaseResp";
13170
+ };
13171
+ return BaseResp;
13172
+ })();
13167
13173
 
13168
13174
  class StreamWriter {
13169
13175
  pool = [];
@@ -13282,6 +13288,31 @@ class AccountStore {
13282
13288
  }
13283
13289
  var accountStore = new AccountStore();
13284
13290
 
13291
+ class IMConfig {
13292
+ uploader = undefined;
13293
+ deviceCode = undefined;
13294
+ deviceType = 7;
13295
+ getUploader() {
13296
+ return this.uploader;
13297
+ }
13298
+ setUploader(uploader) {
13299
+ this.uploader = uploader;
13300
+ }
13301
+ getDeviceCode() {
13302
+ return this.deviceCode;
13303
+ }
13304
+ setDeviceCode(deviceCode) {
13305
+ this.deviceCode = deviceCode;
13306
+ }
13307
+ getDeviceType() {
13308
+ return this.deviceType;
13309
+ }
13310
+ setDeviceType(deviceType) {
13311
+ this.deviceType = deviceType;
13312
+ }
13313
+ }
13314
+ var imConfig = new IMConfig();
13315
+
13285
13316
  const DefaultOptions = {
13286
13317
  webSocketTimeout: 5000,
13287
13318
  signalTimeout: 30000,
@@ -13423,12 +13454,13 @@ class WebSocketServer {
13423
13454
  protocolVersion: SOCKET_PROTOCOL_VER,
13424
13455
  destId: '',
13425
13456
  body: body,
13426
- deviceType: 7
13457
+ deviceCode: imConfig.getDeviceCode() ?? "",
13458
+ deviceType: imConfig.getDeviceType()
13427
13459
  };
13428
13460
  if (cmdId !== CmdIds$1.Heartbean) {
13429
13461
  logger.info(`websocket send -> cmd: 0x${cmdId.toString(16)}, messageSeq: ${messageSeq}`);
13430
13462
  }
13431
- this.socket?.send(buildWsPacketData(rpc_baseExports.NetworkRequest.encode(networkReq).finish()));
13463
+ this.socket?.send(buildWsPacketData(NetworkRequest.encode(networkReq).finish()));
13432
13464
  }
13433
13465
  close() {
13434
13466
  this.autoReconnect = false;
@@ -13482,7 +13514,7 @@ class WebSocketServer {
13482
13514
  const {
13483
13515
  code
13484
13516
  } = await this.send(CmdIds$1.Heartbean, heartbeat, {
13485
- encoder: rpc_baseExports.HeartbeatReq
13517
+ encoder: HeartbeatReq
13486
13518
  }, this.options.pingTimeout);
13487
13519
  if (code === ErrorCode.SUCCESS) {
13488
13520
  logger.debug('recv pong <-');
@@ -13504,7 +13536,7 @@ class WebSocketServer {
13504
13536
  let networkResponse;
13505
13537
  try {
13506
13538
  const payload = resolvePacketData(data);
13507
- networkResponse = rpc_baseExports.NetworkResponse.decode(payload);
13539
+ networkResponse = NetworkResponse.decode(payload);
13508
13540
  } catch (error) {
13509
13541
  logger.error('unpack payload error -> ', error);
13510
13542
  this.onDisconnect(ConnectionStatus.DISCONNECT_BY_SERVER);
@@ -13545,7 +13577,7 @@ class WebSocketServer {
13545
13577
  this.connect();
13546
13578
  }, 5000);
13547
13579
  }
13548
- onConnect() {
13580
+ async onConnect() {
13549
13581
  this.setStatus(ConnectionStatus.CONNECTED);
13550
13582
  this.checkAlive();
13551
13583
  if (isDef(this.reconnectTimer)) {
@@ -13559,6 +13591,7 @@ class WebSocketServer {
13559
13591
  messageSeq
13560
13592
  } = this.pendingMessages.shift();
13561
13593
  this.doSendRawData(cmdId, body, messageSeq);
13594
+ await new Promise(resolve => setTimeout(resolve, 200));
13562
13595
  }
13563
13596
  }
13564
13597
  onDisconnect(error) {
@@ -13635,8 +13668,6 @@ const resolvePacketData = data => {
13635
13668
  };
13636
13669
  var webSocketServer = new WebSocketServer();
13637
13670
 
13638
- var minimalExports = requireMinimal();
13639
-
13640
13671
  /*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
13641
13672
 
13642
13673
  // Common aliases
@@ -18452,7 +18483,7 @@ const splitFullDialog = dialogId => {
18452
18483
  };
18453
18484
 
18454
18485
  const getServerTime$2 = () => webSocketServer.send(CmdIds$1.GetServerTime, null, {
18455
- decoder: rpc_baseExports.SystemCurrentTimeMillisResp
18486
+ decoder: SystemCurrentTimeMillisResp
18456
18487
  });
18457
18488
  const getDialogKey = dialogIds => webSocketServer.send(CmdIds$1.GetDialogKey, {
18458
18489
  destId: dialogIds,
@@ -18487,7 +18518,7 @@ const recallChatMessage = (dialogId, messageUId) => {
18487
18518
  msgId: Long.fromString(messageUId)
18488
18519
  }, {
18489
18520
  encoder: RecallGroupChatMessageReq,
18490
- decoder: rpc_baseExports.BaseResp
18521
+ decoder: BaseResp
18491
18522
  });
18492
18523
  } else {
18493
18524
  reqPromise = webSocketServer.send(CmdIds$1.RecallPrivateMessage, {
@@ -18495,7 +18526,7 @@ const recallChatMessage = (dialogId, messageUId) => {
18495
18526
  msgId: Long.fromString(messageUId)
18496
18527
  }, {
18497
18528
  encoder: RecallPrivateChatMessageReq,
18498
- decoder: rpc_baseExports.BaseResp
18529
+ decoder: BaseResp
18499
18530
  });
18500
18531
  }
18501
18532
  return reqPromise;
@@ -18522,7 +18553,7 @@ const deleteMessages$1 = (dialogId, messageUIds) => {
18522
18553
  msgIdList: messageUIds.map(e => Long.fromString(e))
18523
18554
  }, {
18524
18555
  encoder: DeleteChatMessageReq,
18525
- decoder: rpc_baseExports.BaseResp
18556
+ decoder: BaseResp
18526
18557
  });
18527
18558
  return reqPromise;
18528
18559
  };
@@ -18533,7 +18564,7 @@ const clearHistoryMessage = (dialogId, timestamp) => {
18533
18564
  msgTime: Long.fromNumber(timestamp)
18534
18565
  }, {
18535
18566
  encoder: CleanHistoryMessageReq,
18536
- decoder: rpc_baseExports.BaseResp
18567
+ decoder: BaseResp
18537
18568
  });
18538
18569
  };
18539
18570
  const getDialogList = params => webSocketServer.send(CmdIds$1.GetDialogList, params, {
@@ -18556,7 +18587,7 @@ const updateChatMuteConfig = (dialogId, muteFlag) => {
18556
18587
  muteFlag
18557
18588
  }, {
18558
18589
  encoder: UpdateGroupChatDialogMuteConfigReq,
18559
- decoder: rpc_baseExports.BaseResp
18590
+ decoder: BaseResp
18560
18591
  });
18561
18592
  } else {
18562
18593
  reqPromise = webSocketServer.send(CmdIds$1.UpdatePrivateChatMuteConfig, {
@@ -18564,7 +18595,7 @@ const updateChatMuteConfig = (dialogId, muteFlag) => {
18564
18595
  muteFlag
18565
18596
  }, {
18566
18597
  encoder: UpdatePrivateChatDialogMuteConfigReq,
18567
- decoder: rpc_baseExports.BaseResp
18598
+ decoder: BaseResp
18568
18599
  });
18569
18600
  }
18570
18601
  return reqPromise;
@@ -18577,7 +18608,7 @@ const updateChatStickyConfig = (dialogId, stickyFlag) => {
18577
18608
  stickyFlag
18578
18609
  }, {
18579
18610
  encoder: UpdateGroupChatDialogStickyConfigReq,
18580
- decoder: rpc_baseExports.BaseResp
18611
+ decoder: BaseResp
18581
18612
  });
18582
18613
  } else {
18583
18614
  reqPromise = webSocketServer.send(CmdIds$1.UpdatePrivateChatStickyConfig, {
@@ -18585,7 +18616,7 @@ const updateChatStickyConfig = (dialogId, stickyFlag) => {
18585
18616
  stickyFlag
18586
18617
  }, {
18587
18618
  encoder: UpdatePrivateChatDialogStickyConfigReq,
18588
- decoder: rpc_baseExports.BaseResp
18619
+ decoder: BaseResp
18589
18620
  });
18590
18621
  }
18591
18622
  return reqPromise;
@@ -18597,14 +18628,14 @@ const deleteDialog = dialogId => {
18597
18628
  groupId: Long.fromString(dialogId)
18598
18629
  }, {
18599
18630
  encoder: DeleteGroupChatDialogReq,
18600
- decoder: rpc_baseExports.BaseResp
18631
+ decoder: BaseResp
18601
18632
  });
18602
18633
  } else {
18603
18634
  reqPromise = webSocketServer.send(CmdIds$1.DeletePrivateDialog, {
18604
18635
  destId: Long.fromString(dialogId)
18605
18636
  }, {
18606
18637
  encoder: DeletePrivateChatDialogReq,
18607
- decoder: rpc_baseExports.BaseResp
18638
+ decoder: BaseResp
18608
18639
  });
18609
18640
  }
18610
18641
  return reqPromise;
@@ -26658,17 +26689,6 @@ function requireProtobufjs () {
26658
26689
  var protobufjsExports = requireProtobufjs();
26659
26690
  var protobuf = /*@__PURE__*/getDefaultExportFromCjs(protobufjsExports);
26660
26691
 
26661
- class IMConfig {
26662
- uploader = undefined;
26663
- getUploader() {
26664
- return this.uploader;
26665
- }
26666
- setUploader(uploader) {
26667
- this.uploader = uploader;
26668
- }
26669
- }
26670
- var imConfig = new IMConfig();
26671
-
26672
26692
  const transSentAttrs2IReceivedMessage = (message, options, sentStatus = SentStatus.SENDING) => ({
26673
26693
  conversationType: options.conversation.conversationType,
26674
26694
  targetId: options.conversation.targetId,
@@ -27372,6 +27392,8 @@ class IMClient extends EventEmitter {
27372
27392
  if (isDef(options.uploader)) {
27373
27393
  imConfig.setUploader(options.uploader);
27374
27394
  }
27395
+ imConfig.setDeviceCode(options.deviceCode);
27396
+ imConfig.setDeviceType(options.deviceType);
27375
27397
  this.libLoader = LibLoader.init(options);
27376
27398
  this.watch();
27377
27399
  IMClient.imClient = this;