@sniipwebmaster/user-service-client-grpcweb 25.11.13745 → 25.11.13778

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.
@@ -9167,5 +9167,127 @@ proto.sniipuserservice.SniipUserServiceServicePromiseClient.prototype.disableMfa
9167
9167
  };
9168
9168
 
9169
9169
 
9170
+ /**
9171
+ * @const
9172
+ * @type {!grpc.web.MethodDescriptor<
9173
+ * !proto.sniipuserservice.CreateSwapTokenRequest,
9174
+ * !proto.sniipuserservice.CreateSwapTokenResponse>}
9175
+ */
9176
+ const methodDescriptor_SniipUserServiceService_CreateSwapToken = new grpc.web.MethodDescriptor(
9177
+ '/sniipuserservice.SniipUserServiceService/CreateSwapToken',
9178
+ grpc.web.MethodType.UNARY,
9179
+ proto.sniipuserservice.CreateSwapTokenRequest,
9180
+ proto.sniipuserservice.CreateSwapTokenResponse,
9181
+ /**
9182
+ * @param {!proto.sniipuserservice.CreateSwapTokenRequest} request
9183
+ * @return {!Uint8Array}
9184
+ */
9185
+ function(request) {
9186
+ return request.serializeBinary();
9187
+ },
9188
+ proto.sniipuserservice.CreateSwapTokenResponse.deserializeBinary
9189
+ );
9190
+
9191
+
9192
+ /**
9193
+ * @param {!proto.sniipuserservice.CreateSwapTokenRequest} request The
9194
+ * request proto
9195
+ * @param {?Object<string, string>} metadata User defined
9196
+ * call metadata
9197
+ * @param {function(?grpc.web.RpcError, ?proto.sniipuserservice.CreateSwapTokenResponse)}
9198
+ * callback The callback function(error, response)
9199
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipuserservice.CreateSwapTokenResponse>|undefined}
9200
+ * The XHR Node Readable Stream
9201
+ */
9202
+ proto.sniipuserservice.SniipUserServiceServiceClient.prototype.createSwapToken =
9203
+ function(request, metadata, callback) {
9204
+ return this.client_.rpcCall(this.hostname_ +
9205
+ '/sniipuserservice.SniipUserServiceService/CreateSwapToken',
9206
+ request,
9207
+ metadata || {},
9208
+ methodDescriptor_SniipUserServiceService_CreateSwapToken,
9209
+ callback);
9210
+ };
9211
+
9212
+
9213
+ /**
9214
+ * @param {!proto.sniipuserservice.CreateSwapTokenRequest} request The
9215
+ * request proto
9216
+ * @param {?Object<string, string>=} metadata User defined
9217
+ * call metadata
9218
+ * @return {!Promise<!proto.sniipuserservice.CreateSwapTokenResponse>}
9219
+ * Promise that resolves to the response
9220
+ */
9221
+ proto.sniipuserservice.SniipUserServiceServicePromiseClient.prototype.createSwapToken =
9222
+ function(request, metadata) {
9223
+ return this.client_.unaryCall(this.hostname_ +
9224
+ '/sniipuserservice.SniipUserServiceService/CreateSwapToken',
9225
+ request,
9226
+ metadata || {},
9227
+ methodDescriptor_SniipUserServiceService_CreateSwapToken);
9228
+ };
9229
+
9230
+
9231
+ /**
9232
+ * @const
9233
+ * @type {!grpc.web.MethodDescriptor<
9234
+ * !proto.sniipuserservice.ExchangeSwapTokenRequest,
9235
+ * !proto.sniipuserservice.ExchangeSwapTokenResponse>}
9236
+ */
9237
+ const methodDescriptor_SniipUserServiceService_ExchangeSwapToken = new grpc.web.MethodDescriptor(
9238
+ '/sniipuserservice.SniipUserServiceService/ExchangeSwapToken',
9239
+ grpc.web.MethodType.UNARY,
9240
+ proto.sniipuserservice.ExchangeSwapTokenRequest,
9241
+ proto.sniipuserservice.ExchangeSwapTokenResponse,
9242
+ /**
9243
+ * @param {!proto.sniipuserservice.ExchangeSwapTokenRequest} request
9244
+ * @return {!Uint8Array}
9245
+ */
9246
+ function(request) {
9247
+ return request.serializeBinary();
9248
+ },
9249
+ proto.sniipuserservice.ExchangeSwapTokenResponse.deserializeBinary
9250
+ );
9251
+
9252
+
9253
+ /**
9254
+ * @param {!proto.sniipuserservice.ExchangeSwapTokenRequest} request The
9255
+ * request proto
9256
+ * @param {?Object<string, string>} metadata User defined
9257
+ * call metadata
9258
+ * @param {function(?grpc.web.RpcError, ?proto.sniipuserservice.ExchangeSwapTokenResponse)}
9259
+ * callback The callback function(error, response)
9260
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipuserservice.ExchangeSwapTokenResponse>|undefined}
9261
+ * The XHR Node Readable Stream
9262
+ */
9263
+ proto.sniipuserservice.SniipUserServiceServiceClient.prototype.exchangeSwapToken =
9264
+ function(request, metadata, callback) {
9265
+ return this.client_.rpcCall(this.hostname_ +
9266
+ '/sniipuserservice.SniipUserServiceService/ExchangeSwapToken',
9267
+ request,
9268
+ metadata || {},
9269
+ methodDescriptor_SniipUserServiceService_ExchangeSwapToken,
9270
+ callback);
9271
+ };
9272
+
9273
+
9274
+ /**
9275
+ * @param {!proto.sniipuserservice.ExchangeSwapTokenRequest} request The
9276
+ * request proto
9277
+ * @param {?Object<string, string>=} metadata User defined
9278
+ * call metadata
9279
+ * @return {!Promise<!proto.sniipuserservice.ExchangeSwapTokenResponse>}
9280
+ * Promise that resolves to the response
9281
+ */
9282
+ proto.sniipuserservice.SniipUserServiceServicePromiseClient.prototype.exchangeSwapToken =
9283
+ function(request, metadata) {
9284
+ return this.client_.unaryCall(this.hostname_ +
9285
+ '/sniipuserservice.SniipUserServiceService/ExchangeSwapToken',
9286
+ request,
9287
+ metadata || {},
9288
+ methodDescriptor_SniipUserServiceService_ExchangeSwapToken);
9289
+ };
9290
+
9291
+
9170
9292
  module.exports = proto.sniipuserservice;
9171
9293
 
@@ -48,6 +48,8 @@ goog.exportSymbol('proto.sniipuserservice.CreateSpecificTestEmailAccountRequest'
48
48
  goog.exportSymbol('proto.sniipuserservice.CreateSpecificTestEmailAccountRequestData', null, global);
49
49
  goog.exportSymbol('proto.sniipuserservice.CreateSpecificTestMobileAccountRequest', null, global);
50
50
  goog.exportSymbol('proto.sniipuserservice.CreateSpecificTestMobileAccountRequestData', null, global);
51
+ goog.exportSymbol('proto.sniipuserservice.CreateSwapTokenRequest', null, global);
52
+ goog.exportSymbol('proto.sniipuserservice.CreateSwapTokenResponse', null, global);
51
53
  goog.exportSymbol('proto.sniipuserservice.CreateTestAccountV2Request', null, global);
52
54
  goog.exportSymbol('proto.sniipuserservice.CreateTestEmailAccountRequest', null, global);
53
55
  goog.exportSymbol('proto.sniipuserservice.CreateUserAccountRequest', null, global);
@@ -71,6 +73,8 @@ goog.exportSymbol('proto.sniipuserservice.DisableMfaSecretRequest', null, global
71
73
  goog.exportSymbol('proto.sniipuserservice.DuplicateUsers', null, global);
72
74
  goog.exportSymbol('proto.sniipuserservice.DuplicateUsersRequest', null, global);
73
75
  goog.exportSymbol('proto.sniipuserservice.DuplicateUsersResponse', null, global);
76
+ goog.exportSymbol('proto.sniipuserservice.ExchangeSwapTokenRequest', null, global);
77
+ goog.exportSymbol('proto.sniipuserservice.ExchangeSwapTokenResponse', null, global);
74
78
  goog.exportSymbol('proto.sniipuserservice.FeedbackRequest', null, global);
75
79
  goog.exportSymbol('proto.sniipuserservice.File', null, global);
76
80
  goog.exportSymbol('proto.sniipuserservice.FileUploadRequest', null, global);
@@ -4736,6 +4740,90 @@ if (goog.DEBUG && !COMPILED) {
4736
4740
  */
4737
4741
  proto.sniipuserservice.DisableMfaSecretRequest.displayName = 'proto.sniipuserservice.DisableMfaSecretRequest';
4738
4742
  }
4743
+ /**
4744
+ * Generated by JsPbCodeGenerator.
4745
+ * @param {Array=} opt_data Optional initial data array, typically from a
4746
+ * server response, or constructed directly in Javascript. The array is used
4747
+ * in place and becomes part of the constructed object. It is not cloned.
4748
+ * If no data is provided, the constructed object will be empty, but still
4749
+ * valid.
4750
+ * @extends {jspb.Message}
4751
+ * @constructor
4752
+ */
4753
+ proto.sniipuserservice.CreateSwapTokenRequest = function(opt_data) {
4754
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
4755
+ };
4756
+ goog.inherits(proto.sniipuserservice.CreateSwapTokenRequest, jspb.Message);
4757
+ if (goog.DEBUG && !COMPILED) {
4758
+ /**
4759
+ * @public
4760
+ * @override
4761
+ */
4762
+ proto.sniipuserservice.CreateSwapTokenRequest.displayName = 'proto.sniipuserservice.CreateSwapTokenRequest';
4763
+ }
4764
+ /**
4765
+ * Generated by JsPbCodeGenerator.
4766
+ * @param {Array=} opt_data Optional initial data array, typically from a
4767
+ * server response, or constructed directly in Javascript. The array is used
4768
+ * in place and becomes part of the constructed object. It is not cloned.
4769
+ * If no data is provided, the constructed object will be empty, but still
4770
+ * valid.
4771
+ * @extends {jspb.Message}
4772
+ * @constructor
4773
+ */
4774
+ proto.sniipuserservice.CreateSwapTokenResponse = function(opt_data) {
4775
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
4776
+ };
4777
+ goog.inherits(proto.sniipuserservice.CreateSwapTokenResponse, jspb.Message);
4778
+ if (goog.DEBUG && !COMPILED) {
4779
+ /**
4780
+ * @public
4781
+ * @override
4782
+ */
4783
+ proto.sniipuserservice.CreateSwapTokenResponse.displayName = 'proto.sniipuserservice.CreateSwapTokenResponse';
4784
+ }
4785
+ /**
4786
+ * Generated by JsPbCodeGenerator.
4787
+ * @param {Array=} opt_data Optional initial data array, typically from a
4788
+ * server response, or constructed directly in Javascript. The array is used
4789
+ * in place and becomes part of the constructed object. It is not cloned.
4790
+ * If no data is provided, the constructed object will be empty, but still
4791
+ * valid.
4792
+ * @extends {jspb.Message}
4793
+ * @constructor
4794
+ */
4795
+ proto.sniipuserservice.ExchangeSwapTokenRequest = function(opt_data) {
4796
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
4797
+ };
4798
+ goog.inherits(proto.sniipuserservice.ExchangeSwapTokenRequest, jspb.Message);
4799
+ if (goog.DEBUG && !COMPILED) {
4800
+ /**
4801
+ * @public
4802
+ * @override
4803
+ */
4804
+ proto.sniipuserservice.ExchangeSwapTokenRequest.displayName = 'proto.sniipuserservice.ExchangeSwapTokenRequest';
4805
+ }
4806
+ /**
4807
+ * Generated by JsPbCodeGenerator.
4808
+ * @param {Array=} opt_data Optional initial data array, typically from a
4809
+ * server response, or constructed directly in Javascript. The array is used
4810
+ * in place and becomes part of the constructed object. It is not cloned.
4811
+ * If no data is provided, the constructed object will be empty, but still
4812
+ * valid.
4813
+ * @extends {jspb.Message}
4814
+ * @constructor
4815
+ */
4816
+ proto.sniipuserservice.ExchangeSwapTokenResponse = function(opt_data) {
4817
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
4818
+ };
4819
+ goog.inherits(proto.sniipuserservice.ExchangeSwapTokenResponse, jspb.Message);
4820
+ if (goog.DEBUG && !COMPILED) {
4821
+ /**
4822
+ * @public
4823
+ * @override
4824
+ */
4825
+ proto.sniipuserservice.ExchangeSwapTokenResponse.displayName = 'proto.sniipuserservice.ExchangeSwapTokenResponse';
4826
+ }
4739
4827
 
4740
4828
 
4741
4829
 
@@ -52425,6 +52513,718 @@ proto.sniipuserservice.DisableMfaSecretRequest.prototype.setOtpsource = function
52425
52513
  };
52426
52514
 
52427
52515
 
52516
+
52517
+
52518
+
52519
+ if (jspb.Message.GENERATE_TO_OBJECT) {
52520
+ /**
52521
+ * Creates an object representation of this proto.
52522
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
52523
+ * Optional fields that are not set will be set to undefined.
52524
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
52525
+ * For the list of reserved names please see:
52526
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
52527
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
52528
+ * JSPB instance for transitional soy proto support:
52529
+ * http://goto/soy-param-migration
52530
+ * @return {!Object}
52531
+ */
52532
+ proto.sniipuserservice.CreateSwapTokenRequest.prototype.toObject = function(opt_includeInstance) {
52533
+ return proto.sniipuserservice.CreateSwapTokenRequest.toObject(opt_includeInstance, this);
52534
+ };
52535
+
52536
+
52537
+ /**
52538
+ * Static version of the {@see toObject} method.
52539
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
52540
+ * the JSPB instance for transitional soy proto support:
52541
+ * http://goto/soy-param-migration
52542
+ * @param {!proto.sniipuserservice.CreateSwapTokenRequest} msg The msg instance to transform.
52543
+ * @return {!Object}
52544
+ * @suppress {unusedLocalVariables} f is only used for nested messages
52545
+ */
52546
+ proto.sniipuserservice.CreateSwapTokenRequest.toObject = function(includeInstance, msg) {
52547
+ var f, obj = {
52548
+ redirecturi: jspb.Message.getFieldWithDefault(msg, 1, "")
52549
+ };
52550
+
52551
+ if (includeInstance) {
52552
+ obj.$jspbMessageInstance = msg;
52553
+ }
52554
+ return obj;
52555
+ };
52556
+ }
52557
+
52558
+
52559
+ /**
52560
+ * Deserializes binary data (in protobuf wire format).
52561
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
52562
+ * @return {!proto.sniipuserservice.CreateSwapTokenRequest}
52563
+ */
52564
+ proto.sniipuserservice.CreateSwapTokenRequest.deserializeBinary = function(bytes) {
52565
+ var reader = new jspb.BinaryReader(bytes);
52566
+ var msg = new proto.sniipuserservice.CreateSwapTokenRequest;
52567
+ return proto.sniipuserservice.CreateSwapTokenRequest.deserializeBinaryFromReader(msg, reader);
52568
+ };
52569
+
52570
+
52571
+ /**
52572
+ * Deserializes binary data (in protobuf wire format) from the
52573
+ * given reader into the given message object.
52574
+ * @param {!proto.sniipuserservice.CreateSwapTokenRequest} msg The message object to deserialize into.
52575
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
52576
+ * @return {!proto.sniipuserservice.CreateSwapTokenRequest}
52577
+ */
52578
+ proto.sniipuserservice.CreateSwapTokenRequest.deserializeBinaryFromReader = function(msg, reader) {
52579
+ while (reader.nextField()) {
52580
+ if (reader.isEndGroup()) {
52581
+ break;
52582
+ }
52583
+ var field = reader.getFieldNumber();
52584
+ switch (field) {
52585
+ case 1:
52586
+ var value = /** @type {string} */ (reader.readString());
52587
+ msg.setRedirecturi(value);
52588
+ break;
52589
+ default:
52590
+ reader.skipField();
52591
+ break;
52592
+ }
52593
+ }
52594
+ return msg;
52595
+ };
52596
+
52597
+
52598
+ /**
52599
+ * Serializes the message to binary data (in protobuf wire format).
52600
+ * @return {!Uint8Array}
52601
+ */
52602
+ proto.sniipuserservice.CreateSwapTokenRequest.prototype.serializeBinary = function() {
52603
+ var writer = new jspb.BinaryWriter();
52604
+ proto.sniipuserservice.CreateSwapTokenRequest.serializeBinaryToWriter(this, writer);
52605
+ return writer.getResultBuffer();
52606
+ };
52607
+
52608
+
52609
+ /**
52610
+ * Serializes the given message to binary data (in protobuf wire
52611
+ * format), writing to the given BinaryWriter.
52612
+ * @param {!proto.sniipuserservice.CreateSwapTokenRequest} message
52613
+ * @param {!jspb.BinaryWriter} writer
52614
+ * @suppress {unusedLocalVariables} f is only used for nested messages
52615
+ */
52616
+ proto.sniipuserservice.CreateSwapTokenRequest.serializeBinaryToWriter = function(message, writer) {
52617
+ var f = undefined;
52618
+ f = message.getRedirecturi();
52619
+ if (f.length > 0) {
52620
+ writer.writeString(
52621
+ 1,
52622
+ f
52623
+ );
52624
+ }
52625
+ };
52626
+
52627
+
52628
+ /**
52629
+ * optional string redirectUri = 1;
52630
+ * @return {string}
52631
+ */
52632
+ proto.sniipuserservice.CreateSwapTokenRequest.prototype.getRedirecturi = function() {
52633
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
52634
+ };
52635
+
52636
+
52637
+ /**
52638
+ * @param {string} value
52639
+ * @return {!proto.sniipuserservice.CreateSwapTokenRequest} returns this
52640
+ */
52641
+ proto.sniipuserservice.CreateSwapTokenRequest.prototype.setRedirecturi = function(value) {
52642
+ return jspb.Message.setProto3StringField(this, 1, value);
52643
+ };
52644
+
52645
+
52646
+
52647
+
52648
+
52649
+ if (jspb.Message.GENERATE_TO_OBJECT) {
52650
+ /**
52651
+ * Creates an object representation of this proto.
52652
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
52653
+ * Optional fields that are not set will be set to undefined.
52654
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
52655
+ * For the list of reserved names please see:
52656
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
52657
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
52658
+ * JSPB instance for transitional soy proto support:
52659
+ * http://goto/soy-param-migration
52660
+ * @return {!Object}
52661
+ */
52662
+ proto.sniipuserservice.CreateSwapTokenResponse.prototype.toObject = function(opt_includeInstance) {
52663
+ return proto.sniipuserservice.CreateSwapTokenResponse.toObject(opt_includeInstance, this);
52664
+ };
52665
+
52666
+
52667
+ /**
52668
+ * Static version of the {@see toObject} method.
52669
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
52670
+ * the JSPB instance for transitional soy proto support:
52671
+ * http://goto/soy-param-migration
52672
+ * @param {!proto.sniipuserservice.CreateSwapTokenResponse} msg The msg instance to transform.
52673
+ * @return {!Object}
52674
+ * @suppress {unusedLocalVariables} f is only used for nested messages
52675
+ */
52676
+ proto.sniipuserservice.CreateSwapTokenResponse.toObject = function(includeInstance, msg) {
52677
+ var f, obj = {
52678
+ responsecode: (f = msg.getResponsecode()) && proto.sniipuserservice.ResponseCode.toObject(includeInstance, f),
52679
+ swaptoken: jspb.Message.getFieldWithDefault(msg, 2, ""),
52680
+ expiresat: jspb.Message.getFieldWithDefault(msg, 3, "")
52681
+ };
52682
+
52683
+ if (includeInstance) {
52684
+ obj.$jspbMessageInstance = msg;
52685
+ }
52686
+ return obj;
52687
+ };
52688
+ }
52689
+
52690
+
52691
+ /**
52692
+ * Deserializes binary data (in protobuf wire format).
52693
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
52694
+ * @return {!proto.sniipuserservice.CreateSwapTokenResponse}
52695
+ */
52696
+ proto.sniipuserservice.CreateSwapTokenResponse.deserializeBinary = function(bytes) {
52697
+ var reader = new jspb.BinaryReader(bytes);
52698
+ var msg = new proto.sniipuserservice.CreateSwapTokenResponse;
52699
+ return proto.sniipuserservice.CreateSwapTokenResponse.deserializeBinaryFromReader(msg, reader);
52700
+ };
52701
+
52702
+
52703
+ /**
52704
+ * Deserializes binary data (in protobuf wire format) from the
52705
+ * given reader into the given message object.
52706
+ * @param {!proto.sniipuserservice.CreateSwapTokenResponse} msg The message object to deserialize into.
52707
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
52708
+ * @return {!proto.sniipuserservice.CreateSwapTokenResponse}
52709
+ */
52710
+ proto.sniipuserservice.CreateSwapTokenResponse.deserializeBinaryFromReader = function(msg, reader) {
52711
+ while (reader.nextField()) {
52712
+ if (reader.isEndGroup()) {
52713
+ break;
52714
+ }
52715
+ var field = reader.getFieldNumber();
52716
+ switch (field) {
52717
+ case 1:
52718
+ var value = new proto.sniipuserservice.ResponseCode;
52719
+ reader.readMessage(value,proto.sniipuserservice.ResponseCode.deserializeBinaryFromReader);
52720
+ msg.setResponsecode(value);
52721
+ break;
52722
+ case 2:
52723
+ var value = /** @type {string} */ (reader.readString());
52724
+ msg.setSwaptoken(value);
52725
+ break;
52726
+ case 3:
52727
+ var value = /** @type {string} */ (reader.readString());
52728
+ msg.setExpiresat(value);
52729
+ break;
52730
+ default:
52731
+ reader.skipField();
52732
+ break;
52733
+ }
52734
+ }
52735
+ return msg;
52736
+ };
52737
+
52738
+
52739
+ /**
52740
+ * Serializes the message to binary data (in protobuf wire format).
52741
+ * @return {!Uint8Array}
52742
+ */
52743
+ proto.sniipuserservice.CreateSwapTokenResponse.prototype.serializeBinary = function() {
52744
+ var writer = new jspb.BinaryWriter();
52745
+ proto.sniipuserservice.CreateSwapTokenResponse.serializeBinaryToWriter(this, writer);
52746
+ return writer.getResultBuffer();
52747
+ };
52748
+
52749
+
52750
+ /**
52751
+ * Serializes the given message to binary data (in protobuf wire
52752
+ * format), writing to the given BinaryWriter.
52753
+ * @param {!proto.sniipuserservice.CreateSwapTokenResponse} message
52754
+ * @param {!jspb.BinaryWriter} writer
52755
+ * @suppress {unusedLocalVariables} f is only used for nested messages
52756
+ */
52757
+ proto.sniipuserservice.CreateSwapTokenResponse.serializeBinaryToWriter = function(message, writer) {
52758
+ var f = undefined;
52759
+ f = message.getResponsecode();
52760
+ if (f != null) {
52761
+ writer.writeMessage(
52762
+ 1,
52763
+ f,
52764
+ proto.sniipuserservice.ResponseCode.serializeBinaryToWriter
52765
+ );
52766
+ }
52767
+ f = message.getSwaptoken();
52768
+ if (f.length > 0) {
52769
+ writer.writeString(
52770
+ 2,
52771
+ f
52772
+ );
52773
+ }
52774
+ f = message.getExpiresat();
52775
+ if (f.length > 0) {
52776
+ writer.writeString(
52777
+ 3,
52778
+ f
52779
+ );
52780
+ }
52781
+ };
52782
+
52783
+
52784
+ /**
52785
+ * optional ResponseCode responseCode = 1;
52786
+ * @return {?proto.sniipuserservice.ResponseCode}
52787
+ */
52788
+ proto.sniipuserservice.CreateSwapTokenResponse.prototype.getResponsecode = function() {
52789
+ return /** @type{?proto.sniipuserservice.ResponseCode} */ (
52790
+ jspb.Message.getWrapperField(this, proto.sniipuserservice.ResponseCode, 1));
52791
+ };
52792
+
52793
+
52794
+ /**
52795
+ * @param {?proto.sniipuserservice.ResponseCode|undefined} value
52796
+ * @return {!proto.sniipuserservice.CreateSwapTokenResponse} returns this
52797
+ */
52798
+ proto.sniipuserservice.CreateSwapTokenResponse.prototype.setResponsecode = function(value) {
52799
+ return jspb.Message.setWrapperField(this, 1, value);
52800
+ };
52801
+
52802
+
52803
+ /**
52804
+ * Clears the message field making it undefined.
52805
+ * @return {!proto.sniipuserservice.CreateSwapTokenResponse} returns this
52806
+ */
52807
+ proto.sniipuserservice.CreateSwapTokenResponse.prototype.clearResponsecode = function() {
52808
+ return this.setResponsecode(undefined);
52809
+ };
52810
+
52811
+
52812
+ /**
52813
+ * Returns whether this field is set.
52814
+ * @return {boolean}
52815
+ */
52816
+ proto.sniipuserservice.CreateSwapTokenResponse.prototype.hasResponsecode = function() {
52817
+ return jspb.Message.getField(this, 1) != null;
52818
+ };
52819
+
52820
+
52821
+ /**
52822
+ * optional string swapToken = 2;
52823
+ * @return {string}
52824
+ */
52825
+ proto.sniipuserservice.CreateSwapTokenResponse.prototype.getSwaptoken = function() {
52826
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
52827
+ };
52828
+
52829
+
52830
+ /**
52831
+ * @param {string} value
52832
+ * @return {!proto.sniipuserservice.CreateSwapTokenResponse} returns this
52833
+ */
52834
+ proto.sniipuserservice.CreateSwapTokenResponse.prototype.setSwaptoken = function(value) {
52835
+ return jspb.Message.setProto3StringField(this, 2, value);
52836
+ };
52837
+
52838
+
52839
+ /**
52840
+ * optional string expiresAt = 3;
52841
+ * @return {string}
52842
+ */
52843
+ proto.sniipuserservice.CreateSwapTokenResponse.prototype.getExpiresat = function() {
52844
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
52845
+ };
52846
+
52847
+
52848
+ /**
52849
+ * @param {string} value
52850
+ * @return {!proto.sniipuserservice.CreateSwapTokenResponse} returns this
52851
+ */
52852
+ proto.sniipuserservice.CreateSwapTokenResponse.prototype.setExpiresat = function(value) {
52853
+ return jspb.Message.setProto3StringField(this, 3, value);
52854
+ };
52855
+
52856
+
52857
+
52858
+
52859
+
52860
+ if (jspb.Message.GENERATE_TO_OBJECT) {
52861
+ /**
52862
+ * Creates an object representation of this proto.
52863
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
52864
+ * Optional fields that are not set will be set to undefined.
52865
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
52866
+ * For the list of reserved names please see:
52867
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
52868
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
52869
+ * JSPB instance for transitional soy proto support:
52870
+ * http://goto/soy-param-migration
52871
+ * @return {!Object}
52872
+ */
52873
+ proto.sniipuserservice.ExchangeSwapTokenRequest.prototype.toObject = function(opt_includeInstance) {
52874
+ return proto.sniipuserservice.ExchangeSwapTokenRequest.toObject(opt_includeInstance, this);
52875
+ };
52876
+
52877
+
52878
+ /**
52879
+ * Static version of the {@see toObject} method.
52880
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
52881
+ * the JSPB instance for transitional soy proto support:
52882
+ * http://goto/soy-param-migration
52883
+ * @param {!proto.sniipuserservice.ExchangeSwapTokenRequest} msg The msg instance to transform.
52884
+ * @return {!Object}
52885
+ * @suppress {unusedLocalVariables} f is only used for nested messages
52886
+ */
52887
+ proto.sniipuserservice.ExchangeSwapTokenRequest.toObject = function(includeInstance, msg) {
52888
+ var f, obj = {
52889
+ swaptoken: jspb.Message.getFieldWithDefault(msg, 1, "")
52890
+ };
52891
+
52892
+ if (includeInstance) {
52893
+ obj.$jspbMessageInstance = msg;
52894
+ }
52895
+ return obj;
52896
+ };
52897
+ }
52898
+
52899
+
52900
+ /**
52901
+ * Deserializes binary data (in protobuf wire format).
52902
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
52903
+ * @return {!proto.sniipuserservice.ExchangeSwapTokenRequest}
52904
+ */
52905
+ proto.sniipuserservice.ExchangeSwapTokenRequest.deserializeBinary = function(bytes) {
52906
+ var reader = new jspb.BinaryReader(bytes);
52907
+ var msg = new proto.sniipuserservice.ExchangeSwapTokenRequest;
52908
+ return proto.sniipuserservice.ExchangeSwapTokenRequest.deserializeBinaryFromReader(msg, reader);
52909
+ };
52910
+
52911
+
52912
+ /**
52913
+ * Deserializes binary data (in protobuf wire format) from the
52914
+ * given reader into the given message object.
52915
+ * @param {!proto.sniipuserservice.ExchangeSwapTokenRequest} msg The message object to deserialize into.
52916
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
52917
+ * @return {!proto.sniipuserservice.ExchangeSwapTokenRequest}
52918
+ */
52919
+ proto.sniipuserservice.ExchangeSwapTokenRequest.deserializeBinaryFromReader = function(msg, reader) {
52920
+ while (reader.nextField()) {
52921
+ if (reader.isEndGroup()) {
52922
+ break;
52923
+ }
52924
+ var field = reader.getFieldNumber();
52925
+ switch (field) {
52926
+ case 1:
52927
+ var value = /** @type {string} */ (reader.readString());
52928
+ msg.setSwaptoken(value);
52929
+ break;
52930
+ default:
52931
+ reader.skipField();
52932
+ break;
52933
+ }
52934
+ }
52935
+ return msg;
52936
+ };
52937
+
52938
+
52939
+ /**
52940
+ * Serializes the message to binary data (in protobuf wire format).
52941
+ * @return {!Uint8Array}
52942
+ */
52943
+ proto.sniipuserservice.ExchangeSwapTokenRequest.prototype.serializeBinary = function() {
52944
+ var writer = new jspb.BinaryWriter();
52945
+ proto.sniipuserservice.ExchangeSwapTokenRequest.serializeBinaryToWriter(this, writer);
52946
+ return writer.getResultBuffer();
52947
+ };
52948
+
52949
+
52950
+ /**
52951
+ * Serializes the given message to binary data (in protobuf wire
52952
+ * format), writing to the given BinaryWriter.
52953
+ * @param {!proto.sniipuserservice.ExchangeSwapTokenRequest} message
52954
+ * @param {!jspb.BinaryWriter} writer
52955
+ * @suppress {unusedLocalVariables} f is only used for nested messages
52956
+ */
52957
+ proto.sniipuserservice.ExchangeSwapTokenRequest.serializeBinaryToWriter = function(message, writer) {
52958
+ var f = undefined;
52959
+ f = message.getSwaptoken();
52960
+ if (f.length > 0) {
52961
+ writer.writeString(
52962
+ 1,
52963
+ f
52964
+ );
52965
+ }
52966
+ };
52967
+
52968
+
52969
+ /**
52970
+ * optional string swapToken = 1;
52971
+ * @return {string}
52972
+ */
52973
+ proto.sniipuserservice.ExchangeSwapTokenRequest.prototype.getSwaptoken = function() {
52974
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
52975
+ };
52976
+
52977
+
52978
+ /**
52979
+ * @param {string} value
52980
+ * @return {!proto.sniipuserservice.ExchangeSwapTokenRequest} returns this
52981
+ */
52982
+ proto.sniipuserservice.ExchangeSwapTokenRequest.prototype.setSwaptoken = function(value) {
52983
+ return jspb.Message.setProto3StringField(this, 1, value);
52984
+ };
52985
+
52986
+
52987
+
52988
+
52989
+
52990
+ if (jspb.Message.GENERATE_TO_OBJECT) {
52991
+ /**
52992
+ * Creates an object representation of this proto.
52993
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
52994
+ * Optional fields that are not set will be set to undefined.
52995
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
52996
+ * For the list of reserved names please see:
52997
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
52998
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
52999
+ * JSPB instance for transitional soy proto support:
53000
+ * http://goto/soy-param-migration
53001
+ * @return {!Object}
53002
+ */
53003
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.toObject = function(opt_includeInstance) {
53004
+ return proto.sniipuserservice.ExchangeSwapTokenResponse.toObject(opt_includeInstance, this);
53005
+ };
53006
+
53007
+
53008
+ /**
53009
+ * Static version of the {@see toObject} method.
53010
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
53011
+ * the JSPB instance for transitional soy proto support:
53012
+ * http://goto/soy-param-migration
53013
+ * @param {!proto.sniipuserservice.ExchangeSwapTokenResponse} msg The msg instance to transform.
53014
+ * @return {!Object}
53015
+ * @suppress {unusedLocalVariables} f is only used for nested messages
53016
+ */
53017
+ proto.sniipuserservice.ExchangeSwapTokenResponse.toObject = function(includeInstance, msg) {
53018
+ var f, obj = {
53019
+ responsecode: (f = msg.getResponsecode()) && proto.sniipuserservice.ResponseCode.toObject(includeInstance, f),
53020
+ accesstoken: jspb.Message.getFieldWithDefault(msg, 2, ""),
53021
+ tokentype: jspb.Message.getFieldWithDefault(msg, 3, ""),
53022
+ expiresin: jspb.Message.getFieldWithDefault(msg, 4, 0)
53023
+ };
53024
+
53025
+ if (includeInstance) {
53026
+ obj.$jspbMessageInstance = msg;
53027
+ }
53028
+ return obj;
53029
+ };
53030
+ }
53031
+
53032
+
53033
+ /**
53034
+ * Deserializes binary data (in protobuf wire format).
53035
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
53036
+ * @return {!proto.sniipuserservice.ExchangeSwapTokenResponse}
53037
+ */
53038
+ proto.sniipuserservice.ExchangeSwapTokenResponse.deserializeBinary = function(bytes) {
53039
+ var reader = new jspb.BinaryReader(bytes);
53040
+ var msg = new proto.sniipuserservice.ExchangeSwapTokenResponse;
53041
+ return proto.sniipuserservice.ExchangeSwapTokenResponse.deserializeBinaryFromReader(msg, reader);
53042
+ };
53043
+
53044
+
53045
+ /**
53046
+ * Deserializes binary data (in protobuf wire format) from the
53047
+ * given reader into the given message object.
53048
+ * @param {!proto.sniipuserservice.ExchangeSwapTokenResponse} msg The message object to deserialize into.
53049
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
53050
+ * @return {!proto.sniipuserservice.ExchangeSwapTokenResponse}
53051
+ */
53052
+ proto.sniipuserservice.ExchangeSwapTokenResponse.deserializeBinaryFromReader = function(msg, reader) {
53053
+ while (reader.nextField()) {
53054
+ if (reader.isEndGroup()) {
53055
+ break;
53056
+ }
53057
+ var field = reader.getFieldNumber();
53058
+ switch (field) {
53059
+ case 1:
53060
+ var value = new proto.sniipuserservice.ResponseCode;
53061
+ reader.readMessage(value,proto.sniipuserservice.ResponseCode.deserializeBinaryFromReader);
53062
+ msg.setResponsecode(value);
53063
+ break;
53064
+ case 2:
53065
+ var value = /** @type {string} */ (reader.readString());
53066
+ msg.setAccesstoken(value);
53067
+ break;
53068
+ case 3:
53069
+ var value = /** @type {string} */ (reader.readString());
53070
+ msg.setTokentype(value);
53071
+ break;
53072
+ case 4:
53073
+ var value = /** @type {number} */ (reader.readInt32());
53074
+ msg.setExpiresin(value);
53075
+ break;
53076
+ default:
53077
+ reader.skipField();
53078
+ break;
53079
+ }
53080
+ }
53081
+ return msg;
53082
+ };
53083
+
53084
+
53085
+ /**
53086
+ * Serializes the message to binary data (in protobuf wire format).
53087
+ * @return {!Uint8Array}
53088
+ */
53089
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.serializeBinary = function() {
53090
+ var writer = new jspb.BinaryWriter();
53091
+ proto.sniipuserservice.ExchangeSwapTokenResponse.serializeBinaryToWriter(this, writer);
53092
+ return writer.getResultBuffer();
53093
+ };
53094
+
53095
+
53096
+ /**
53097
+ * Serializes the given message to binary data (in protobuf wire
53098
+ * format), writing to the given BinaryWriter.
53099
+ * @param {!proto.sniipuserservice.ExchangeSwapTokenResponse} message
53100
+ * @param {!jspb.BinaryWriter} writer
53101
+ * @suppress {unusedLocalVariables} f is only used for nested messages
53102
+ */
53103
+ proto.sniipuserservice.ExchangeSwapTokenResponse.serializeBinaryToWriter = function(message, writer) {
53104
+ var f = undefined;
53105
+ f = message.getResponsecode();
53106
+ if (f != null) {
53107
+ writer.writeMessage(
53108
+ 1,
53109
+ f,
53110
+ proto.sniipuserservice.ResponseCode.serializeBinaryToWriter
53111
+ );
53112
+ }
53113
+ f = message.getAccesstoken();
53114
+ if (f.length > 0) {
53115
+ writer.writeString(
53116
+ 2,
53117
+ f
53118
+ );
53119
+ }
53120
+ f = message.getTokentype();
53121
+ if (f.length > 0) {
53122
+ writer.writeString(
53123
+ 3,
53124
+ f
53125
+ );
53126
+ }
53127
+ f = message.getExpiresin();
53128
+ if (f !== 0) {
53129
+ writer.writeInt32(
53130
+ 4,
53131
+ f
53132
+ );
53133
+ }
53134
+ };
53135
+
53136
+
53137
+ /**
53138
+ * optional ResponseCode responseCode = 1;
53139
+ * @return {?proto.sniipuserservice.ResponseCode}
53140
+ */
53141
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.getResponsecode = function() {
53142
+ return /** @type{?proto.sniipuserservice.ResponseCode} */ (
53143
+ jspb.Message.getWrapperField(this, proto.sniipuserservice.ResponseCode, 1));
53144
+ };
53145
+
53146
+
53147
+ /**
53148
+ * @param {?proto.sniipuserservice.ResponseCode|undefined} value
53149
+ * @return {!proto.sniipuserservice.ExchangeSwapTokenResponse} returns this
53150
+ */
53151
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.setResponsecode = function(value) {
53152
+ return jspb.Message.setWrapperField(this, 1, value);
53153
+ };
53154
+
53155
+
53156
+ /**
53157
+ * Clears the message field making it undefined.
53158
+ * @return {!proto.sniipuserservice.ExchangeSwapTokenResponse} returns this
53159
+ */
53160
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.clearResponsecode = function() {
53161
+ return this.setResponsecode(undefined);
53162
+ };
53163
+
53164
+
53165
+ /**
53166
+ * Returns whether this field is set.
53167
+ * @return {boolean}
53168
+ */
53169
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.hasResponsecode = function() {
53170
+ return jspb.Message.getField(this, 1) != null;
53171
+ };
53172
+
53173
+
53174
+ /**
53175
+ * optional string accessToken = 2;
53176
+ * @return {string}
53177
+ */
53178
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.getAccesstoken = function() {
53179
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
53180
+ };
53181
+
53182
+
53183
+ /**
53184
+ * @param {string} value
53185
+ * @return {!proto.sniipuserservice.ExchangeSwapTokenResponse} returns this
53186
+ */
53187
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.setAccesstoken = function(value) {
53188
+ return jspb.Message.setProto3StringField(this, 2, value);
53189
+ };
53190
+
53191
+
53192
+ /**
53193
+ * optional string tokenType = 3;
53194
+ * @return {string}
53195
+ */
53196
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.getTokentype = function() {
53197
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
53198
+ };
53199
+
53200
+
53201
+ /**
53202
+ * @param {string} value
53203
+ * @return {!proto.sniipuserservice.ExchangeSwapTokenResponse} returns this
53204
+ */
53205
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.setTokentype = function(value) {
53206
+ return jspb.Message.setProto3StringField(this, 3, value);
53207
+ };
53208
+
53209
+
53210
+ /**
53211
+ * optional int32 expiresIn = 4;
53212
+ * @return {number}
53213
+ */
53214
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.getExpiresin = function() {
53215
+ return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));
53216
+ };
53217
+
53218
+
53219
+ /**
53220
+ * @param {number} value
53221
+ * @return {!proto.sniipuserservice.ExchangeSwapTokenResponse} returns this
53222
+ */
53223
+ proto.sniipuserservice.ExchangeSwapTokenResponse.prototype.setExpiresin = function(value) {
53224
+ return jspb.Message.setProto3IntField(this, 4, value);
53225
+ };
53226
+
53227
+
52428
53228
  /**
52429
53229
  * @enum {number}
52430
53230
  */
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@sniipwebmaster/user-service-client-grpcweb",
3
- "version": "25.11.13745",
3
+ "version": "25.11.13778",
4
4
  "description": "user-service-client-grpcweb",
5
5
  "author": "Sniip Development Team",
6
6
  "license": "MIT",