@sniipwebmaster/user-service-client-grpcweb 22.11.7898 → 22.11.7925

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.
@@ -2714,6 +2714,86 @@ proto.sniipuserservice.SniipUserServiceServicePromiseClient.prototype.getAvailab
2714
2714
  };
2715
2715
 
2716
2716
 
2717
+ /**
2718
+ * @const
2719
+ * @type {!grpc.web.MethodDescriptor<
2720
+ * !proto.sniipuserservice.GetDuplicatesUsersRequest,
2721
+ * !proto.sniipuserservice.DuplicateUsersResponse>}
2722
+ */
2723
+ const methodDescriptor_SniipUserServiceService_GetDuplicatesUsers = new grpc.web.MethodDescriptor(
2724
+ '/sniipuserservice.SniipUserServiceService/GetDuplicatesUsers',
2725
+ grpc.web.MethodType.UNARY,
2726
+ proto.sniipuserservice.GetDuplicatesUsersRequest,
2727
+ proto.sniipuserservice.DuplicateUsersResponse,
2728
+ /**
2729
+ * @param {!proto.sniipuserservice.GetDuplicatesUsersRequest} request
2730
+ * @return {!Uint8Array}
2731
+ */
2732
+ function(request) {
2733
+ return request.serializeBinary();
2734
+ },
2735
+ proto.sniipuserservice.DuplicateUsersResponse.deserializeBinary
2736
+ );
2737
+
2738
+
2739
+ /**
2740
+ * @const
2741
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2742
+ * !proto.sniipuserservice.GetDuplicatesUsersRequest,
2743
+ * !proto.sniipuserservice.DuplicateUsersResponse>}
2744
+ */
2745
+ const methodInfo_SniipUserServiceService_GetDuplicatesUsers = new grpc.web.AbstractClientBase.MethodInfo(
2746
+ proto.sniipuserservice.DuplicateUsersResponse,
2747
+ /**
2748
+ * @param {!proto.sniipuserservice.GetDuplicatesUsersRequest} request
2749
+ * @return {!Uint8Array}
2750
+ */
2751
+ function(request) {
2752
+ return request.serializeBinary();
2753
+ },
2754
+ proto.sniipuserservice.DuplicateUsersResponse.deserializeBinary
2755
+ );
2756
+
2757
+
2758
+ /**
2759
+ * @param {!proto.sniipuserservice.GetDuplicatesUsersRequest} request The
2760
+ * request proto
2761
+ * @param {?Object<string, string>} metadata User defined
2762
+ * call metadata
2763
+ * @param {function(?grpc.web.Error, ?proto.sniipuserservice.DuplicateUsersResponse)}
2764
+ * callback The callback function(error, response)
2765
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipuserservice.DuplicateUsersResponse>|undefined}
2766
+ * The XHR Node Readable Stream
2767
+ */
2768
+ proto.sniipuserservice.SniipUserServiceServiceClient.prototype.getDuplicatesUsers =
2769
+ function(request, metadata, callback) {
2770
+ return this.client_.rpcCall(this.hostname_ +
2771
+ '/sniipuserservice.SniipUserServiceService/GetDuplicatesUsers',
2772
+ request,
2773
+ metadata || {},
2774
+ methodDescriptor_SniipUserServiceService_GetDuplicatesUsers,
2775
+ callback);
2776
+ };
2777
+
2778
+
2779
+ /**
2780
+ * @param {!proto.sniipuserservice.GetDuplicatesUsersRequest} request The
2781
+ * request proto
2782
+ * @param {?Object<string, string>} metadata User defined
2783
+ * call metadata
2784
+ * @return {!Promise<!proto.sniipuserservice.DuplicateUsersResponse>}
2785
+ * Promise that resolves to the response
2786
+ */
2787
+ proto.sniipuserservice.SniipUserServiceServicePromiseClient.prototype.getDuplicatesUsers =
2788
+ function(request, metadata) {
2789
+ return this.client_.unaryCall(this.hostname_ +
2790
+ '/sniipuserservice.SniipUserServiceService/GetDuplicatesUsers',
2791
+ request,
2792
+ metadata || {},
2793
+ methodDescriptor_SniipUserServiceService_GetDuplicatesUsers);
2794
+ };
2795
+
2796
+
2717
2797
  /**
2718
2798
  * @const
2719
2799
  * @type {!grpc.web.MethodDescriptor<
@@ -53,9 +53,13 @@ goog.exportSymbol('proto.sniipuserservice.DeleteBillerRolesRequest', null, globa
53
53
  goog.exportSymbol('proto.sniipuserservice.DeleteTestAccountRequest', null, global);
54
54
  goog.exportSymbol('proto.sniipuserservice.DeleteUserAccountRequest', null, global);
55
55
  goog.exportSymbol('proto.sniipuserservice.DeviceDetails', null, global);
56
+ goog.exportSymbol('proto.sniipuserservice.DuplicateUsers', null, global);
57
+ goog.exportSymbol('proto.sniipuserservice.DuplicateUsersRequest', null, global);
58
+ goog.exportSymbol('proto.sniipuserservice.DuplicateUsersResponse', null, global);
56
59
  goog.exportSymbol('proto.sniipuserservice.FeedbackRequest', null, global);
57
60
  goog.exportSymbol('proto.sniipuserservice.GetAssignedPermissionRolesRequest', null, global);
58
61
  goog.exportSymbol('proto.sniipuserservice.GetAvailablePermissionRolesRequest', null, global);
62
+ goog.exportSymbol('proto.sniipuserservice.GetDuplicatesUsersRequest', null, global);
59
63
  goog.exportSymbol('proto.sniipuserservice.GetInternalProfileByApiKeyRequest', null, global);
60
64
  goog.exportSymbol('proto.sniipuserservice.GetInternalProfileFromEmailRequest', null, global);
61
65
  goog.exportSymbol('proto.sniipuserservice.GetInternalProfileRequest', null, global);
@@ -11167,6 +11171,601 @@ proto.sniipuserservice.DeviceDetails.prototype.setUpdatedat = function(value) {
11167
11171
 
11168
11172
 
11169
11173
 
11174
+ /**
11175
+ * Generated by JsPbCodeGenerator.
11176
+ * @param {Array=} opt_data Optional initial data array, typically from a
11177
+ * server response, or constructed directly in Javascript. The array is used
11178
+ * in place and becomes part of the constructed object. It is not cloned.
11179
+ * If no data is provided, the constructed object will be empty, but still
11180
+ * valid.
11181
+ * @extends {jspb.Message}
11182
+ * @constructor
11183
+ */
11184
+ proto.sniipuserservice.DuplicateUsers = function(opt_data) {
11185
+ jspb.Message.initialize(this, opt_data, 0, -1, proto.sniipuserservice.DuplicateUsers.repeatedFields_, null);
11186
+ };
11187
+ goog.inherits(proto.sniipuserservice.DuplicateUsers, jspb.Message);
11188
+ if (goog.DEBUG && !COMPILED) {
11189
+ proto.sniipuserservice.DuplicateUsers.displayName = 'proto.sniipuserservice.DuplicateUsers';
11190
+ }
11191
+ /**
11192
+ * List of repeated fields within this message type.
11193
+ * @private {!Array<number>}
11194
+ * @const
11195
+ */
11196
+ proto.sniipuserservice.DuplicateUsers.repeatedFields_ = [1];
11197
+
11198
+
11199
+
11200
+ if (jspb.Message.GENERATE_TO_OBJECT) {
11201
+ /**
11202
+ * Creates an object representation of this proto suitable for use in Soy templates.
11203
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
11204
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
11205
+ * For the list of reserved names please see:
11206
+ * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS.
11207
+ * @param {boolean=} opt_includeInstance Whether to include the JSPB instance
11208
+ * for transitional soy proto support: http://goto/soy-param-migration
11209
+ * @return {!Object}
11210
+ */
11211
+ proto.sniipuserservice.DuplicateUsers.prototype.toObject = function(opt_includeInstance) {
11212
+ return proto.sniipuserservice.DuplicateUsers.toObject(opt_includeInstance, this);
11213
+ };
11214
+
11215
+
11216
+ /**
11217
+ * Static version of the {@see toObject} method.
11218
+ * @param {boolean|undefined} includeInstance Whether to include the JSPB
11219
+ * instance for transitional soy proto support:
11220
+ * http://goto/soy-param-migration
11221
+ * @param {!proto.sniipuserservice.DuplicateUsers} msg The msg instance to transform.
11222
+ * @return {!Object}
11223
+ */
11224
+ proto.sniipuserservice.DuplicateUsers.toObject = function(includeInstance, msg) {
11225
+ var f, obj = {
11226
+ duplicateusersList: jspb.Message.getField(msg, 1),
11227
+ userid: msg.getUserid()
11228
+ };
11229
+
11230
+ if (includeInstance) {
11231
+ obj.$jspbMessageInstance = msg;
11232
+ }
11233
+ return obj;
11234
+ };
11235
+ }
11236
+
11237
+
11238
+ /**
11239
+ * Deserializes binary data (in protobuf wire format).
11240
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
11241
+ * @return {!proto.sniipuserservice.DuplicateUsers}
11242
+ */
11243
+ proto.sniipuserservice.DuplicateUsers.deserializeBinary = function(bytes) {
11244
+ var reader = new jspb.BinaryReader(bytes);
11245
+ var msg = new proto.sniipuserservice.DuplicateUsers;
11246
+ return proto.sniipuserservice.DuplicateUsers.deserializeBinaryFromReader(msg, reader);
11247
+ };
11248
+
11249
+
11250
+ /**
11251
+ * Deserializes binary data (in protobuf wire format) from the
11252
+ * given reader into the given message object.
11253
+ * @param {!proto.sniipuserservice.DuplicateUsers} msg The message object to deserialize into.
11254
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
11255
+ * @return {!proto.sniipuserservice.DuplicateUsers}
11256
+ */
11257
+ proto.sniipuserservice.DuplicateUsers.deserializeBinaryFromReader = function(msg, reader) {
11258
+ while (reader.nextField()) {
11259
+ if (reader.isEndGroup()) {
11260
+ break;
11261
+ }
11262
+ var field = reader.getFieldNumber();
11263
+ switch (field) {
11264
+ case 1:
11265
+ var value = /** @type {!Array.<number>} */ (reader.readPackedInt64());
11266
+ msg.setDuplicateusersList(value);
11267
+ break;
11268
+ case 2:
11269
+ var value = /** @type {number} */ (reader.readInt64());
11270
+ msg.setUserid(value);
11271
+ break;
11272
+ default:
11273
+ reader.skipField();
11274
+ break;
11275
+ }
11276
+ }
11277
+ return msg;
11278
+ };
11279
+
11280
+
11281
+ /**
11282
+ * Class method variant: serializes the given message to binary data
11283
+ * (in protobuf wire format), writing to the given BinaryWriter.
11284
+ * @param {!proto.sniipuserservice.DuplicateUsers} message
11285
+ * @param {!jspb.BinaryWriter} writer
11286
+ */
11287
+ proto.sniipuserservice.DuplicateUsers.serializeBinaryToWriter = function(message, writer) {
11288
+ message.serializeBinaryToWriter(writer);
11289
+ };
11290
+
11291
+
11292
+ /**
11293
+ * Serializes the message to binary data (in protobuf wire format).
11294
+ * @return {!Uint8Array}
11295
+ */
11296
+ proto.sniipuserservice.DuplicateUsers.prototype.serializeBinary = function() {
11297
+ var writer = new jspb.BinaryWriter();
11298
+ this.serializeBinaryToWriter(writer);
11299
+ return writer.getResultBuffer();
11300
+ };
11301
+
11302
+
11303
+ /**
11304
+ * Serializes the message to binary data (in protobuf wire format),
11305
+ * writing to the given BinaryWriter.
11306
+ * @param {!jspb.BinaryWriter} writer
11307
+ */
11308
+ proto.sniipuserservice.DuplicateUsers.prototype.serializeBinaryToWriter = function (writer) {
11309
+ var f = undefined;
11310
+ f = this.getDuplicateusersList();
11311
+ if (f.length > 0) {
11312
+ writer.writePackedInt64(
11313
+ 1,
11314
+ f
11315
+ );
11316
+ }
11317
+ f = this.getUserid();
11318
+ if (f !== 0) {
11319
+ writer.writeInt64(
11320
+ 2,
11321
+ f
11322
+ );
11323
+ }
11324
+ };
11325
+
11326
+
11327
+ /**
11328
+ * Creates a deep clone of this proto. No data is shared with the original.
11329
+ * @return {!proto.sniipuserservice.DuplicateUsers} The clone.
11330
+ */
11331
+ proto.sniipuserservice.DuplicateUsers.prototype.cloneMessage = function() {
11332
+ return /** @type {!proto.sniipuserservice.DuplicateUsers} */ (jspb.Message.cloneMessage(this));
11333
+ };
11334
+
11335
+
11336
+ /**
11337
+ * repeated int64 duplicateUsers = 1;
11338
+ * If you change this array by adding, removing or replacing elements, or if you
11339
+ * replace the array itself, then you must call the setter to update it.
11340
+ * @return {!Array.<number>}
11341
+ */
11342
+ proto.sniipuserservice.DuplicateUsers.prototype.getDuplicateusersList = function() {
11343
+ return /** @type {!Array.<number>} */ (jspb.Message.getField(this, 1));
11344
+ };
11345
+
11346
+
11347
+ /** @param {Array.<number>} value */
11348
+ proto.sniipuserservice.DuplicateUsers.prototype.setDuplicateusersList = function(value) {
11349
+ jspb.Message.setField(this, 1, value || []);
11350
+ };
11351
+
11352
+
11353
+ proto.sniipuserservice.DuplicateUsers.prototype.clearDuplicateusersList = function() {
11354
+ jspb.Message.setField(this, 1, []);
11355
+ };
11356
+
11357
+
11358
+ /**
11359
+ * optional int64 userId = 2;
11360
+ * @return {number}
11361
+ */
11362
+ proto.sniipuserservice.DuplicateUsers.prototype.getUserid = function() {
11363
+ return /** @type {number} */ (jspb.Message.getFieldProto3(this, 2, 0));
11364
+ };
11365
+
11366
+
11367
+ /** @param {number} value */
11368
+ proto.sniipuserservice.DuplicateUsers.prototype.setUserid = function(value) {
11369
+ jspb.Message.setField(this, 2, value);
11370
+ };
11371
+
11372
+
11373
+
11374
+ /**
11375
+ * Generated by JsPbCodeGenerator.
11376
+ * @param {Array=} opt_data Optional initial data array, typically from a
11377
+ * server response, or constructed directly in Javascript. The array is used
11378
+ * in place and becomes part of the constructed object. It is not cloned.
11379
+ * If no data is provided, the constructed object will be empty, but still
11380
+ * valid.
11381
+ * @extends {jspb.Message}
11382
+ * @constructor
11383
+ */
11384
+ proto.sniipuserservice.DuplicateUsersRequest = function(opt_data) {
11385
+ jspb.Message.initialize(this, opt_data, 0, -1, proto.sniipuserservice.DuplicateUsersRequest.repeatedFields_, null);
11386
+ };
11387
+ goog.inherits(proto.sniipuserservice.DuplicateUsersRequest, jspb.Message);
11388
+ if (goog.DEBUG && !COMPILED) {
11389
+ proto.sniipuserservice.DuplicateUsersRequest.displayName = 'proto.sniipuserservice.DuplicateUsersRequest';
11390
+ }
11391
+ /**
11392
+ * List of repeated fields within this message type.
11393
+ * @private {!Array<number>}
11394
+ * @const
11395
+ */
11396
+ proto.sniipuserservice.DuplicateUsersRequest.repeatedFields_ = [1];
11397
+
11398
+
11399
+
11400
+ if (jspb.Message.GENERATE_TO_OBJECT) {
11401
+ /**
11402
+ * Creates an object representation of this proto suitable for use in Soy templates.
11403
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
11404
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
11405
+ * For the list of reserved names please see:
11406
+ * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS.
11407
+ * @param {boolean=} opt_includeInstance Whether to include the JSPB instance
11408
+ * for transitional soy proto support: http://goto/soy-param-migration
11409
+ * @return {!Object}
11410
+ */
11411
+ proto.sniipuserservice.DuplicateUsersRequest.prototype.toObject = function(opt_includeInstance) {
11412
+ return proto.sniipuserservice.DuplicateUsersRequest.toObject(opt_includeInstance, this);
11413
+ };
11414
+
11415
+
11416
+ /**
11417
+ * Static version of the {@see toObject} method.
11418
+ * @param {boolean|undefined} includeInstance Whether to include the JSPB
11419
+ * instance for transitional soy proto support:
11420
+ * http://goto/soy-param-migration
11421
+ * @param {!proto.sniipuserservice.DuplicateUsersRequest} msg The msg instance to transform.
11422
+ * @return {!Object}
11423
+ */
11424
+ proto.sniipuserservice.DuplicateUsersRequest.toObject = function(includeInstance, msg) {
11425
+ var f, obj = {
11426
+ useridsList: jspb.Message.getField(msg, 1)
11427
+ };
11428
+
11429
+ if (includeInstance) {
11430
+ obj.$jspbMessageInstance = msg;
11431
+ }
11432
+ return obj;
11433
+ };
11434
+ }
11435
+
11436
+
11437
+ /**
11438
+ * Deserializes binary data (in protobuf wire format).
11439
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
11440
+ * @return {!proto.sniipuserservice.DuplicateUsersRequest}
11441
+ */
11442
+ proto.sniipuserservice.DuplicateUsersRequest.deserializeBinary = function(bytes) {
11443
+ var reader = new jspb.BinaryReader(bytes);
11444
+ var msg = new proto.sniipuserservice.DuplicateUsersRequest;
11445
+ return proto.sniipuserservice.DuplicateUsersRequest.deserializeBinaryFromReader(msg, reader);
11446
+ };
11447
+
11448
+
11449
+ /**
11450
+ * Deserializes binary data (in protobuf wire format) from the
11451
+ * given reader into the given message object.
11452
+ * @param {!proto.sniipuserservice.DuplicateUsersRequest} msg The message object to deserialize into.
11453
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
11454
+ * @return {!proto.sniipuserservice.DuplicateUsersRequest}
11455
+ */
11456
+ proto.sniipuserservice.DuplicateUsersRequest.deserializeBinaryFromReader = function(msg, reader) {
11457
+ while (reader.nextField()) {
11458
+ if (reader.isEndGroup()) {
11459
+ break;
11460
+ }
11461
+ var field = reader.getFieldNumber();
11462
+ switch (field) {
11463
+ case 1:
11464
+ var value = /** @type {!Array.<number>} */ (reader.readPackedInt64());
11465
+ msg.setUseridsList(value);
11466
+ break;
11467
+ default:
11468
+ reader.skipField();
11469
+ break;
11470
+ }
11471
+ }
11472
+ return msg;
11473
+ };
11474
+
11475
+
11476
+ /**
11477
+ * Class method variant: serializes the given message to binary data
11478
+ * (in protobuf wire format), writing to the given BinaryWriter.
11479
+ * @param {!proto.sniipuserservice.DuplicateUsersRequest} message
11480
+ * @param {!jspb.BinaryWriter} writer
11481
+ */
11482
+ proto.sniipuserservice.DuplicateUsersRequest.serializeBinaryToWriter = function(message, writer) {
11483
+ message.serializeBinaryToWriter(writer);
11484
+ };
11485
+
11486
+
11487
+ /**
11488
+ * Serializes the message to binary data (in protobuf wire format).
11489
+ * @return {!Uint8Array}
11490
+ */
11491
+ proto.sniipuserservice.DuplicateUsersRequest.prototype.serializeBinary = function() {
11492
+ var writer = new jspb.BinaryWriter();
11493
+ this.serializeBinaryToWriter(writer);
11494
+ return writer.getResultBuffer();
11495
+ };
11496
+
11497
+
11498
+ /**
11499
+ * Serializes the message to binary data (in protobuf wire format),
11500
+ * writing to the given BinaryWriter.
11501
+ * @param {!jspb.BinaryWriter} writer
11502
+ */
11503
+ proto.sniipuserservice.DuplicateUsersRequest.prototype.serializeBinaryToWriter = function (writer) {
11504
+ var f = undefined;
11505
+ f = this.getUseridsList();
11506
+ if (f.length > 0) {
11507
+ writer.writePackedInt64(
11508
+ 1,
11509
+ f
11510
+ );
11511
+ }
11512
+ };
11513
+
11514
+
11515
+ /**
11516
+ * Creates a deep clone of this proto. No data is shared with the original.
11517
+ * @return {!proto.sniipuserservice.DuplicateUsersRequest} The clone.
11518
+ */
11519
+ proto.sniipuserservice.DuplicateUsersRequest.prototype.cloneMessage = function() {
11520
+ return /** @type {!proto.sniipuserservice.DuplicateUsersRequest} */ (jspb.Message.cloneMessage(this));
11521
+ };
11522
+
11523
+
11524
+ /**
11525
+ * repeated int64 userIds = 1;
11526
+ * If you change this array by adding, removing or replacing elements, or if you
11527
+ * replace the array itself, then you must call the setter to update it.
11528
+ * @return {!Array.<number>}
11529
+ */
11530
+ proto.sniipuserservice.DuplicateUsersRequest.prototype.getUseridsList = function() {
11531
+ return /** @type {!Array.<number>} */ (jspb.Message.getField(this, 1));
11532
+ };
11533
+
11534
+
11535
+ /** @param {Array.<number>} value */
11536
+ proto.sniipuserservice.DuplicateUsersRequest.prototype.setUseridsList = function(value) {
11537
+ jspb.Message.setField(this, 1, value || []);
11538
+ };
11539
+
11540
+
11541
+ proto.sniipuserservice.DuplicateUsersRequest.prototype.clearUseridsList = function() {
11542
+ jspb.Message.setField(this, 1, []);
11543
+ };
11544
+
11545
+
11546
+
11547
+ /**
11548
+ * Generated by JsPbCodeGenerator.
11549
+ * @param {Array=} opt_data Optional initial data array, typically from a
11550
+ * server response, or constructed directly in Javascript. The array is used
11551
+ * in place and becomes part of the constructed object. It is not cloned.
11552
+ * If no data is provided, the constructed object will be empty, but still
11553
+ * valid.
11554
+ * @extends {jspb.Message}
11555
+ * @constructor
11556
+ */
11557
+ proto.sniipuserservice.DuplicateUsersResponse = function(opt_data) {
11558
+ jspb.Message.initialize(this, opt_data, 0, -1, proto.sniipuserservice.DuplicateUsersResponse.repeatedFields_, null);
11559
+ };
11560
+ goog.inherits(proto.sniipuserservice.DuplicateUsersResponse, jspb.Message);
11561
+ if (goog.DEBUG && !COMPILED) {
11562
+ proto.sniipuserservice.DuplicateUsersResponse.displayName = 'proto.sniipuserservice.DuplicateUsersResponse';
11563
+ }
11564
+ /**
11565
+ * List of repeated fields within this message type.
11566
+ * @private {!Array<number>}
11567
+ * @const
11568
+ */
11569
+ proto.sniipuserservice.DuplicateUsersResponse.repeatedFields_ = [1];
11570
+
11571
+
11572
+
11573
+ if (jspb.Message.GENERATE_TO_OBJECT) {
11574
+ /**
11575
+ * Creates an object representation of this proto suitable for use in Soy templates.
11576
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
11577
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
11578
+ * For the list of reserved names please see:
11579
+ * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS.
11580
+ * @param {boolean=} opt_includeInstance Whether to include the JSPB instance
11581
+ * for transitional soy proto support: http://goto/soy-param-migration
11582
+ * @return {!Object}
11583
+ */
11584
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.toObject = function(opt_includeInstance) {
11585
+ return proto.sniipuserservice.DuplicateUsersResponse.toObject(opt_includeInstance, this);
11586
+ };
11587
+
11588
+
11589
+ /**
11590
+ * Static version of the {@see toObject} method.
11591
+ * @param {boolean|undefined} includeInstance Whether to include the JSPB
11592
+ * instance for transitional soy proto support:
11593
+ * http://goto/soy-param-migration
11594
+ * @param {!proto.sniipuserservice.DuplicateUsersResponse} msg The msg instance to transform.
11595
+ * @return {!Object}
11596
+ */
11597
+ proto.sniipuserservice.DuplicateUsersResponse.toObject = function(includeInstance, msg) {
11598
+ var f, obj = {
11599
+ dataList: jspb.Message.toObjectList(msg.getDataList(),
11600
+ proto.sniipuserservice.DuplicateUsers.toObject, includeInstance),
11601
+ responsecode: (f = msg.getResponsecode()) && proto.sniipuserservice.ResponseCode.toObject(includeInstance, f)
11602
+ };
11603
+
11604
+ if (includeInstance) {
11605
+ obj.$jspbMessageInstance = msg;
11606
+ }
11607
+ return obj;
11608
+ };
11609
+ }
11610
+
11611
+
11612
+ /**
11613
+ * Deserializes binary data (in protobuf wire format).
11614
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
11615
+ * @return {!proto.sniipuserservice.DuplicateUsersResponse}
11616
+ */
11617
+ proto.sniipuserservice.DuplicateUsersResponse.deserializeBinary = function(bytes) {
11618
+ var reader = new jspb.BinaryReader(bytes);
11619
+ var msg = new proto.sniipuserservice.DuplicateUsersResponse;
11620
+ return proto.sniipuserservice.DuplicateUsersResponse.deserializeBinaryFromReader(msg, reader);
11621
+ };
11622
+
11623
+
11624
+ /**
11625
+ * Deserializes binary data (in protobuf wire format) from the
11626
+ * given reader into the given message object.
11627
+ * @param {!proto.sniipuserservice.DuplicateUsersResponse} msg The message object to deserialize into.
11628
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
11629
+ * @return {!proto.sniipuserservice.DuplicateUsersResponse}
11630
+ */
11631
+ proto.sniipuserservice.DuplicateUsersResponse.deserializeBinaryFromReader = function(msg, reader) {
11632
+ while (reader.nextField()) {
11633
+ if (reader.isEndGroup()) {
11634
+ break;
11635
+ }
11636
+ var field = reader.getFieldNumber();
11637
+ switch (field) {
11638
+ case 1:
11639
+ var value = new proto.sniipuserservice.DuplicateUsers;
11640
+ reader.readMessage(value,proto.sniipuserservice.DuplicateUsers.deserializeBinaryFromReader);
11641
+ msg.getDataList().push(value);
11642
+ msg.setDataList(msg.getDataList());
11643
+ break;
11644
+ case 2:
11645
+ var value = new proto.sniipuserservice.ResponseCode;
11646
+ reader.readMessage(value,proto.sniipuserservice.ResponseCode.deserializeBinaryFromReader);
11647
+ msg.setResponsecode(value);
11648
+ break;
11649
+ default:
11650
+ reader.skipField();
11651
+ break;
11652
+ }
11653
+ }
11654
+ return msg;
11655
+ };
11656
+
11657
+
11658
+ /**
11659
+ * Class method variant: serializes the given message to binary data
11660
+ * (in protobuf wire format), writing to the given BinaryWriter.
11661
+ * @param {!proto.sniipuserservice.DuplicateUsersResponse} message
11662
+ * @param {!jspb.BinaryWriter} writer
11663
+ */
11664
+ proto.sniipuserservice.DuplicateUsersResponse.serializeBinaryToWriter = function(message, writer) {
11665
+ message.serializeBinaryToWriter(writer);
11666
+ };
11667
+
11668
+
11669
+ /**
11670
+ * Serializes the message to binary data (in protobuf wire format).
11671
+ * @return {!Uint8Array}
11672
+ */
11673
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.serializeBinary = function() {
11674
+ var writer = new jspb.BinaryWriter();
11675
+ this.serializeBinaryToWriter(writer);
11676
+ return writer.getResultBuffer();
11677
+ };
11678
+
11679
+
11680
+ /**
11681
+ * Serializes the message to binary data (in protobuf wire format),
11682
+ * writing to the given BinaryWriter.
11683
+ * @param {!jspb.BinaryWriter} writer
11684
+ */
11685
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.serializeBinaryToWriter = function (writer) {
11686
+ var f = undefined;
11687
+ f = this.getDataList();
11688
+ if (f.length > 0) {
11689
+ writer.writeRepeatedMessage(
11690
+ 1,
11691
+ f,
11692
+ proto.sniipuserservice.DuplicateUsers.serializeBinaryToWriter
11693
+ );
11694
+ }
11695
+ f = this.getResponsecode();
11696
+ if (f != null) {
11697
+ writer.writeMessage(
11698
+ 2,
11699
+ f,
11700
+ proto.sniipuserservice.ResponseCode.serializeBinaryToWriter
11701
+ );
11702
+ }
11703
+ };
11704
+
11705
+
11706
+ /**
11707
+ * Creates a deep clone of this proto. No data is shared with the original.
11708
+ * @return {!proto.sniipuserservice.DuplicateUsersResponse} The clone.
11709
+ */
11710
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.cloneMessage = function() {
11711
+ return /** @type {!proto.sniipuserservice.DuplicateUsersResponse} */ (jspb.Message.cloneMessage(this));
11712
+ };
11713
+
11714
+
11715
+ /**
11716
+ * repeated DuplicateUsers data = 1;
11717
+ * If you change this array by adding, removing or replacing elements, or if you
11718
+ * replace the array itself, then you must call the setter to update it.
11719
+ * @return {!Array.<!proto.sniipuserservice.DuplicateUsers>}
11720
+ */
11721
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.getDataList = function() {
11722
+ return /** @type{!Array.<!proto.sniipuserservice.DuplicateUsers>} */ (
11723
+ jspb.Message.getRepeatedWrapperField(this, proto.sniipuserservice.DuplicateUsers, 1));
11724
+ };
11725
+
11726
+
11727
+ /** @param {Array.<!proto.sniipuserservice.DuplicateUsers>} value */
11728
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.setDataList = function(value) {
11729
+ jspb.Message.setRepeatedWrapperField(this, 1, value);
11730
+ };
11731
+
11732
+
11733
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.clearDataList = function() {
11734
+ this.setDataList([]);
11735
+ };
11736
+
11737
+
11738
+ /**
11739
+ * optional ResponseCode responseCode = 2;
11740
+ * @return {proto.sniipuserservice.ResponseCode}
11741
+ */
11742
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.getResponsecode = function() {
11743
+ return /** @type{proto.sniipuserservice.ResponseCode} */ (
11744
+ jspb.Message.getWrapperField(this, proto.sniipuserservice.ResponseCode, 2));
11745
+ };
11746
+
11747
+
11748
+ /** @param {proto.sniipuserservice.ResponseCode|undefined} value */
11749
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.setResponsecode = function(value) {
11750
+ jspb.Message.setWrapperField(this, 2, value);
11751
+ };
11752
+
11753
+
11754
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.clearResponsecode = function() {
11755
+ this.setResponsecode(undefined);
11756
+ };
11757
+
11758
+
11759
+ /**
11760
+ * Returns whether this field is set.
11761
+ * @return{!boolean}
11762
+ */
11763
+ proto.sniipuserservice.DuplicateUsersResponse.prototype.hasResponsecode = function() {
11764
+ return jspb.Message.getField(this, 2) != null;
11765
+ };
11766
+
11767
+
11768
+
11170
11769
  /**
11171
11770
  * Generated by JsPbCodeGenerator.
11172
11771
  * @param {Array=} opt_data Optional initial data array, typically from a
@@ -12076,6 +12675,182 @@ proto.sniipuserservice.GetAvailablePermissionRolesRequest.prototype.setUserid =
12076
12675
 
12077
12676
 
12078
12677
 
12678
+ /**
12679
+ * Generated by JsPbCodeGenerator.
12680
+ * @param {Array=} opt_data Optional initial data array, typically from a
12681
+ * server response, or constructed directly in Javascript. The array is used
12682
+ * in place and becomes part of the constructed object. It is not cloned.
12683
+ * If no data is provided, the constructed object will be empty, but still
12684
+ * valid.
12685
+ * @extends {jspb.Message}
12686
+ * @constructor
12687
+ */
12688
+ proto.sniipuserservice.GetDuplicatesUsersRequest = function(opt_data) {
12689
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
12690
+ };
12691
+ goog.inherits(proto.sniipuserservice.GetDuplicatesUsersRequest, jspb.Message);
12692
+ if (goog.DEBUG && !COMPILED) {
12693
+ proto.sniipuserservice.GetDuplicatesUsersRequest.displayName = 'proto.sniipuserservice.GetDuplicatesUsersRequest';
12694
+ }
12695
+
12696
+
12697
+ if (jspb.Message.GENERATE_TO_OBJECT) {
12698
+ /**
12699
+ * Creates an object representation of this proto suitable for use in Soy templates.
12700
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
12701
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
12702
+ * For the list of reserved names please see:
12703
+ * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS.
12704
+ * @param {boolean=} opt_includeInstance Whether to include the JSPB instance
12705
+ * for transitional soy proto support: http://goto/soy-param-migration
12706
+ * @return {!Object}
12707
+ */
12708
+ proto.sniipuserservice.GetDuplicatesUsersRequest.prototype.toObject = function(opt_includeInstance) {
12709
+ return proto.sniipuserservice.GetDuplicatesUsersRequest.toObject(opt_includeInstance, this);
12710
+ };
12711
+
12712
+
12713
+ /**
12714
+ * Static version of the {@see toObject} method.
12715
+ * @param {boolean|undefined} includeInstance Whether to include the JSPB
12716
+ * instance for transitional soy proto support:
12717
+ * http://goto/soy-param-migration
12718
+ * @param {!proto.sniipuserservice.GetDuplicatesUsersRequest} msg The msg instance to transform.
12719
+ * @return {!Object}
12720
+ */
12721
+ proto.sniipuserservice.GetDuplicatesUsersRequest.toObject = function(includeInstance, msg) {
12722
+ var f, obj = {
12723
+ data: (f = msg.getData()) && proto.sniipuserservice.DuplicateUsersRequest.toObject(includeInstance, f)
12724
+ };
12725
+
12726
+ if (includeInstance) {
12727
+ obj.$jspbMessageInstance = msg;
12728
+ }
12729
+ return obj;
12730
+ };
12731
+ }
12732
+
12733
+
12734
+ /**
12735
+ * Deserializes binary data (in protobuf wire format).
12736
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
12737
+ * @return {!proto.sniipuserservice.GetDuplicatesUsersRequest}
12738
+ */
12739
+ proto.sniipuserservice.GetDuplicatesUsersRequest.deserializeBinary = function(bytes) {
12740
+ var reader = new jspb.BinaryReader(bytes);
12741
+ var msg = new proto.sniipuserservice.GetDuplicatesUsersRequest;
12742
+ return proto.sniipuserservice.GetDuplicatesUsersRequest.deserializeBinaryFromReader(msg, reader);
12743
+ };
12744
+
12745
+
12746
+ /**
12747
+ * Deserializes binary data (in protobuf wire format) from the
12748
+ * given reader into the given message object.
12749
+ * @param {!proto.sniipuserservice.GetDuplicatesUsersRequest} msg The message object to deserialize into.
12750
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
12751
+ * @return {!proto.sniipuserservice.GetDuplicatesUsersRequest}
12752
+ */
12753
+ proto.sniipuserservice.GetDuplicatesUsersRequest.deserializeBinaryFromReader = function(msg, reader) {
12754
+ while (reader.nextField()) {
12755
+ if (reader.isEndGroup()) {
12756
+ break;
12757
+ }
12758
+ var field = reader.getFieldNumber();
12759
+ switch (field) {
12760
+ case 1:
12761
+ var value = new proto.sniipuserservice.DuplicateUsersRequest;
12762
+ reader.readMessage(value,proto.sniipuserservice.DuplicateUsersRequest.deserializeBinaryFromReader);
12763
+ msg.setData(value);
12764
+ break;
12765
+ default:
12766
+ reader.skipField();
12767
+ break;
12768
+ }
12769
+ }
12770
+ return msg;
12771
+ };
12772
+
12773
+
12774
+ /**
12775
+ * Class method variant: serializes the given message to binary data
12776
+ * (in protobuf wire format), writing to the given BinaryWriter.
12777
+ * @param {!proto.sniipuserservice.GetDuplicatesUsersRequest} message
12778
+ * @param {!jspb.BinaryWriter} writer
12779
+ */
12780
+ proto.sniipuserservice.GetDuplicatesUsersRequest.serializeBinaryToWriter = function(message, writer) {
12781
+ message.serializeBinaryToWriter(writer);
12782
+ };
12783
+
12784
+
12785
+ /**
12786
+ * Serializes the message to binary data (in protobuf wire format).
12787
+ * @return {!Uint8Array}
12788
+ */
12789
+ proto.sniipuserservice.GetDuplicatesUsersRequest.prototype.serializeBinary = function() {
12790
+ var writer = new jspb.BinaryWriter();
12791
+ this.serializeBinaryToWriter(writer);
12792
+ return writer.getResultBuffer();
12793
+ };
12794
+
12795
+
12796
+ /**
12797
+ * Serializes the message to binary data (in protobuf wire format),
12798
+ * writing to the given BinaryWriter.
12799
+ * @param {!jspb.BinaryWriter} writer
12800
+ */
12801
+ proto.sniipuserservice.GetDuplicatesUsersRequest.prototype.serializeBinaryToWriter = function (writer) {
12802
+ var f = undefined;
12803
+ f = this.getData();
12804
+ if (f != null) {
12805
+ writer.writeMessage(
12806
+ 1,
12807
+ f,
12808
+ proto.sniipuserservice.DuplicateUsersRequest.serializeBinaryToWriter
12809
+ );
12810
+ }
12811
+ };
12812
+
12813
+
12814
+ /**
12815
+ * Creates a deep clone of this proto. No data is shared with the original.
12816
+ * @return {!proto.sniipuserservice.GetDuplicatesUsersRequest} The clone.
12817
+ */
12818
+ proto.sniipuserservice.GetDuplicatesUsersRequest.prototype.cloneMessage = function() {
12819
+ return /** @type {!proto.sniipuserservice.GetDuplicatesUsersRequest} */ (jspb.Message.cloneMessage(this));
12820
+ };
12821
+
12822
+
12823
+ /**
12824
+ * optional DuplicateUsersRequest data = 1;
12825
+ * @return {proto.sniipuserservice.DuplicateUsersRequest}
12826
+ */
12827
+ proto.sniipuserservice.GetDuplicatesUsersRequest.prototype.getData = function() {
12828
+ return /** @type{proto.sniipuserservice.DuplicateUsersRequest} */ (
12829
+ jspb.Message.getWrapperField(this, proto.sniipuserservice.DuplicateUsersRequest, 1));
12830
+ };
12831
+
12832
+
12833
+ /** @param {proto.sniipuserservice.DuplicateUsersRequest|undefined} value */
12834
+ proto.sniipuserservice.GetDuplicatesUsersRequest.prototype.setData = function(value) {
12835
+ jspb.Message.setWrapperField(this, 1, value);
12836
+ };
12837
+
12838
+
12839
+ proto.sniipuserservice.GetDuplicatesUsersRequest.prototype.clearData = function() {
12840
+ this.setData(undefined);
12841
+ };
12842
+
12843
+
12844
+ /**
12845
+ * Returns whether this field is set.
12846
+ * @return{!boolean}
12847
+ */
12848
+ proto.sniipuserservice.GetDuplicatesUsersRequest.prototype.hasData = function() {
12849
+ return jspb.Message.getField(this, 1) != null;
12850
+ };
12851
+
12852
+
12853
+
12079
12854
  /**
12080
12855
  * Generated by JsPbCodeGenerator.
12081
12856
  * @param {Array=} opt_data Optional initial data array, typically from a
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@sniipwebmaster/user-service-client-grpcweb",
3
- "version": "22.11.7898",
3
+ "version": "22.11.7925",
4
4
  "description": "user-service-client-grpcweb",
5
5
  "author": "Sniip Development Team",
6
6
  "license": "MIT",