@sniipwebmaster/bill-service-client-grpcweb 23.7.11763 → 23.7.11776

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.
@@ -0,0 +1,4558 @@
1
+ /**
2
+ * @fileoverview gRPC-Web generated client stub for sniipbillapi
3
+ * @enhanceable
4
+ * @public
5
+ */
6
+
7
+ // GENERATED CODE -- DO NOT EDIT!
8
+
9
+
10
+ /* eslint-disable */
11
+ // @ts-nocheck
12
+
13
+
14
+
15
+ const grpc = {};
16
+ grpc.web = require('grpc-web');
17
+
18
+
19
+ var google_api_annotations_pb = require('./google/api/annotations_pb.js')
20
+
21
+ var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js')
22
+ const proto = {};
23
+ proto.sniipbillapi = require('./service_pb.js');
24
+
25
+ /**
26
+ * @param {string} hostname
27
+ * @param {?Object} credentials
28
+ * @param {?Object} options
29
+ * @constructor
30
+ * @struct
31
+ * @final
32
+ */
33
+ proto.sniipbillapi.SniipBillAPIServiceClient =
34
+ function(hostname, credentials, options) {
35
+ if (!options) options = {};
36
+ options['format'] = 'text';
37
+
38
+ /**
39
+ * @private @const {!grpc.web.GrpcWebClientBase} The client
40
+ */
41
+ this.client_ = new grpc.web.GrpcWebClientBase(options);
42
+
43
+ /**
44
+ * @private @const {string} The hostname
45
+ */
46
+ this.hostname_ = hostname;
47
+
48
+ };
49
+
50
+
51
+ /**
52
+ * @param {string} hostname
53
+ * @param {?Object} credentials
54
+ * @param {?Object} options
55
+ * @constructor
56
+ * @struct
57
+ * @final
58
+ */
59
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient =
60
+ function(hostname, credentials, options) {
61
+ if (!options) options = {};
62
+ options['format'] = 'text';
63
+
64
+ /**
65
+ * @private @const {!grpc.web.GrpcWebClientBase} The client
66
+ */
67
+ this.client_ = new grpc.web.GrpcWebClientBase(options);
68
+
69
+ /**
70
+ * @private @const {string} The hostname
71
+ */
72
+ this.hostname_ = hostname;
73
+
74
+ };
75
+
76
+
77
+ /**
78
+ * @const
79
+ * @type {!grpc.web.MethodDescriptor<
80
+ * !proto.sniipbillapi.AddHybridInfoRequest,
81
+ * !proto.sniipbillapi.ResponseCode>}
82
+ */
83
+ const methodDescriptor_SniipBillAPIService_AddHybridInfo = new grpc.web.MethodDescriptor(
84
+ '/sniipbillapi.SniipBillAPIService/AddHybridInfo',
85
+ grpc.web.MethodType.UNARY,
86
+ proto.sniipbillapi.AddHybridInfoRequest,
87
+ proto.sniipbillapi.ResponseCode,
88
+ /**
89
+ * @param {!proto.sniipbillapi.AddHybridInfoRequest} request
90
+ * @return {!Uint8Array}
91
+ */
92
+ function(request) {
93
+ return request.serializeBinary();
94
+ },
95
+ proto.sniipbillapi.ResponseCode.deserializeBinary
96
+ );
97
+
98
+
99
+ /**
100
+ * @const
101
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
102
+ * !proto.sniipbillapi.AddHybridInfoRequest,
103
+ * !proto.sniipbillapi.ResponseCode>}
104
+ */
105
+ const methodInfo_SniipBillAPIService_AddHybridInfo = new grpc.web.AbstractClientBase.MethodInfo(
106
+ proto.sniipbillapi.ResponseCode,
107
+ /**
108
+ * @param {!proto.sniipbillapi.AddHybridInfoRequest} request
109
+ * @return {!Uint8Array}
110
+ */
111
+ function(request) {
112
+ return request.serializeBinary();
113
+ },
114
+ proto.sniipbillapi.ResponseCode.deserializeBinary
115
+ );
116
+
117
+
118
+ /**
119
+ * @param {!proto.sniipbillapi.AddHybridInfoRequest} request The
120
+ * request proto
121
+ * @param {?Object<string, string>} metadata User defined
122
+ * call metadata
123
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
124
+ * callback The callback function(error, response)
125
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
126
+ * The XHR Node Readable Stream
127
+ */
128
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.addHybridInfo =
129
+ function(request, metadata, callback) {
130
+ return this.client_.rpcCall(this.hostname_ +
131
+ '/sniipbillapi.SniipBillAPIService/AddHybridInfo',
132
+ request,
133
+ metadata || {},
134
+ methodDescriptor_SniipBillAPIService_AddHybridInfo,
135
+ callback);
136
+ };
137
+
138
+
139
+ /**
140
+ * @param {!proto.sniipbillapi.AddHybridInfoRequest} request The
141
+ * request proto
142
+ * @param {?Object<string, string>} metadata User defined
143
+ * call metadata
144
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
145
+ * Promise that resolves to the response
146
+ */
147
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.addHybridInfo =
148
+ function(request, metadata) {
149
+ return this.client_.unaryCall(this.hostname_ +
150
+ '/sniipbillapi.SniipBillAPIService/AddHybridInfo',
151
+ request,
152
+ metadata || {},
153
+ methodDescriptor_SniipBillAPIService_AddHybridInfo);
154
+ };
155
+
156
+
157
+ /**
158
+ * @const
159
+ * @type {!grpc.web.MethodDescriptor<
160
+ * !proto.sniipbillapi.BadgeCountRequest,
161
+ * !proto.sniipbillapi.BadgeCountResponse>}
162
+ */
163
+ const methodDescriptor_SniipBillAPIService_BadgeCount = new grpc.web.MethodDescriptor(
164
+ '/sniipbillapi.SniipBillAPIService/BadgeCount',
165
+ grpc.web.MethodType.UNARY,
166
+ proto.sniipbillapi.BadgeCountRequest,
167
+ proto.sniipbillapi.BadgeCountResponse,
168
+ /**
169
+ * @param {!proto.sniipbillapi.BadgeCountRequest} request
170
+ * @return {!Uint8Array}
171
+ */
172
+ function(request) {
173
+ return request.serializeBinary();
174
+ },
175
+ proto.sniipbillapi.BadgeCountResponse.deserializeBinary
176
+ );
177
+
178
+
179
+ /**
180
+ * @const
181
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
182
+ * !proto.sniipbillapi.BadgeCountRequest,
183
+ * !proto.sniipbillapi.BadgeCountResponse>}
184
+ */
185
+ const methodInfo_SniipBillAPIService_BadgeCount = new grpc.web.AbstractClientBase.MethodInfo(
186
+ proto.sniipbillapi.BadgeCountResponse,
187
+ /**
188
+ * @param {!proto.sniipbillapi.BadgeCountRequest} request
189
+ * @return {!Uint8Array}
190
+ */
191
+ function(request) {
192
+ return request.serializeBinary();
193
+ },
194
+ proto.sniipbillapi.BadgeCountResponse.deserializeBinary
195
+ );
196
+
197
+
198
+ /**
199
+ * @param {!proto.sniipbillapi.BadgeCountRequest} request The
200
+ * request proto
201
+ * @param {?Object<string, string>} metadata User defined
202
+ * call metadata
203
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BadgeCountResponse)}
204
+ * callback The callback function(error, response)
205
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BadgeCountResponse>|undefined}
206
+ * The XHR Node Readable Stream
207
+ */
208
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.badgeCount =
209
+ function(request, metadata, callback) {
210
+ return this.client_.rpcCall(this.hostname_ +
211
+ '/sniipbillapi.SniipBillAPIService/BadgeCount',
212
+ request,
213
+ metadata || {},
214
+ methodDescriptor_SniipBillAPIService_BadgeCount,
215
+ callback);
216
+ };
217
+
218
+
219
+ /**
220
+ * @param {!proto.sniipbillapi.BadgeCountRequest} request The
221
+ * request proto
222
+ * @param {?Object<string, string>} metadata User defined
223
+ * call metadata
224
+ * @return {!Promise<!proto.sniipbillapi.BadgeCountResponse>}
225
+ * Promise that resolves to the response
226
+ */
227
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.badgeCount =
228
+ function(request, metadata) {
229
+ return this.client_.unaryCall(this.hostname_ +
230
+ '/sniipbillapi.SniipBillAPIService/BadgeCount',
231
+ request,
232
+ metadata || {},
233
+ methodDescriptor_SniipBillAPIService_BadgeCount);
234
+ };
235
+
236
+
237
+ /**
238
+ * @const
239
+ * @type {!grpc.web.MethodDescriptor<
240
+ * !proto.sniipbillapi.BillBillInternalRequest,
241
+ * !proto.sniipbillapi.BillDetails>}
242
+ */
243
+ const methodDescriptor_SniipBillAPIService_BillBillInternal = new grpc.web.MethodDescriptor(
244
+ '/sniipbillapi.SniipBillAPIService/BillBillInternal',
245
+ grpc.web.MethodType.UNARY,
246
+ proto.sniipbillapi.BillBillInternalRequest,
247
+ proto.sniipbillapi.BillDetails,
248
+ /**
249
+ * @param {!proto.sniipbillapi.BillBillInternalRequest} request
250
+ * @return {!Uint8Array}
251
+ */
252
+ function(request) {
253
+ return request.serializeBinary();
254
+ },
255
+ proto.sniipbillapi.BillDetails.deserializeBinary
256
+ );
257
+
258
+
259
+ /**
260
+ * @const
261
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
262
+ * !proto.sniipbillapi.BillBillInternalRequest,
263
+ * !proto.sniipbillapi.BillDetails>}
264
+ */
265
+ const methodInfo_SniipBillAPIService_BillBillInternal = new grpc.web.AbstractClientBase.MethodInfo(
266
+ proto.sniipbillapi.BillDetails,
267
+ /**
268
+ * @param {!proto.sniipbillapi.BillBillInternalRequest} request
269
+ * @return {!Uint8Array}
270
+ */
271
+ function(request) {
272
+ return request.serializeBinary();
273
+ },
274
+ proto.sniipbillapi.BillDetails.deserializeBinary
275
+ );
276
+
277
+
278
+ /**
279
+ * @param {!proto.sniipbillapi.BillBillInternalRequest} request The
280
+ * request proto
281
+ * @param {?Object<string, string>} metadata User defined
282
+ * call metadata
283
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillDetails)}
284
+ * callback The callback function(error, response)
285
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillDetails>|undefined}
286
+ * The XHR Node Readable Stream
287
+ */
288
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.billBillInternal =
289
+ function(request, metadata, callback) {
290
+ return this.client_.rpcCall(this.hostname_ +
291
+ '/sniipbillapi.SniipBillAPIService/BillBillInternal',
292
+ request,
293
+ metadata || {},
294
+ methodDescriptor_SniipBillAPIService_BillBillInternal,
295
+ callback);
296
+ };
297
+
298
+
299
+ /**
300
+ * @param {!proto.sniipbillapi.BillBillInternalRequest} request The
301
+ * request proto
302
+ * @param {?Object<string, string>} metadata User defined
303
+ * call metadata
304
+ * @return {!Promise<!proto.sniipbillapi.BillDetails>}
305
+ * Promise that resolves to the response
306
+ */
307
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.billBillInternal =
308
+ function(request, metadata) {
309
+ return this.client_.unaryCall(this.hostname_ +
310
+ '/sniipbillapi.SniipBillAPIService/BillBillInternal',
311
+ request,
312
+ metadata || {},
313
+ methodDescriptor_SniipBillAPIService_BillBillInternal);
314
+ };
315
+
316
+
317
+ /**
318
+ * @const
319
+ * @type {!grpc.web.MethodDescriptor<
320
+ * !proto.google.protobuf.Empty,
321
+ * !proto.sniipbillapi.ResponseCode>}
322
+ */
323
+ const methodDescriptor_SniipBillAPIService_CleanOldAnonymousBill = new grpc.web.MethodDescriptor(
324
+ '/sniipbillapi.SniipBillAPIService/CleanOldAnonymousBill',
325
+ grpc.web.MethodType.UNARY,
326
+ google_protobuf_empty_pb.Empty,
327
+ proto.sniipbillapi.ResponseCode,
328
+ /**
329
+ * @param {!proto.google.protobuf.Empty} request
330
+ * @return {!Uint8Array}
331
+ */
332
+ function(request) {
333
+ return request.serializeBinary();
334
+ },
335
+ proto.sniipbillapi.ResponseCode.deserializeBinary
336
+ );
337
+
338
+
339
+ /**
340
+ * @const
341
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
342
+ * !proto.google.protobuf.Empty,
343
+ * !proto.sniipbillapi.ResponseCode>}
344
+ */
345
+ const methodInfo_SniipBillAPIService_CleanOldAnonymousBill = new grpc.web.AbstractClientBase.MethodInfo(
346
+ proto.sniipbillapi.ResponseCode,
347
+ /**
348
+ * @param {!proto.google.protobuf.Empty} request
349
+ * @return {!Uint8Array}
350
+ */
351
+ function(request) {
352
+ return request.serializeBinary();
353
+ },
354
+ proto.sniipbillapi.ResponseCode.deserializeBinary
355
+ );
356
+
357
+
358
+ /**
359
+ * @param {!proto.google.protobuf.Empty} request The
360
+ * request proto
361
+ * @param {?Object<string, string>} metadata User defined
362
+ * call metadata
363
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
364
+ * callback The callback function(error, response)
365
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
366
+ * The XHR Node Readable Stream
367
+ */
368
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.cleanOldAnonymousBill =
369
+ function(request, metadata, callback) {
370
+ return this.client_.rpcCall(this.hostname_ +
371
+ '/sniipbillapi.SniipBillAPIService/CleanOldAnonymousBill',
372
+ request,
373
+ metadata || {},
374
+ methodDescriptor_SniipBillAPIService_CleanOldAnonymousBill,
375
+ callback);
376
+ };
377
+
378
+
379
+ /**
380
+ * @param {!proto.google.protobuf.Empty} request The
381
+ * request proto
382
+ * @param {?Object<string, string>} metadata User defined
383
+ * call metadata
384
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
385
+ * Promise that resolves to the response
386
+ */
387
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.cleanOldAnonymousBill =
388
+ function(request, metadata) {
389
+ return this.client_.unaryCall(this.hostname_ +
390
+ '/sniipbillapi.SniipBillAPIService/CleanOldAnonymousBill',
391
+ request,
392
+ metadata || {},
393
+ methodDescriptor_SniipBillAPIService_CleanOldAnonymousBill);
394
+ };
395
+
396
+
397
+ /**
398
+ * @const
399
+ * @type {!grpc.web.MethodDescriptor<
400
+ * !proto.sniipbillapi.CopyExistingBillRequest,
401
+ * !proto.sniipbillapi.SimpleBillResponse>}
402
+ */
403
+ const methodDescriptor_SniipBillAPIService_CopyExistingBill = new grpc.web.MethodDescriptor(
404
+ '/sniipbillapi.SniipBillAPIService/CopyExistingBill',
405
+ grpc.web.MethodType.UNARY,
406
+ proto.sniipbillapi.CopyExistingBillRequest,
407
+ proto.sniipbillapi.SimpleBillResponse,
408
+ /**
409
+ * @param {!proto.sniipbillapi.CopyExistingBillRequest} request
410
+ * @return {!Uint8Array}
411
+ */
412
+ function(request) {
413
+ return request.serializeBinary();
414
+ },
415
+ proto.sniipbillapi.SimpleBillResponse.deserializeBinary
416
+ );
417
+
418
+
419
+ /**
420
+ * @const
421
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
422
+ * !proto.sniipbillapi.CopyExistingBillRequest,
423
+ * !proto.sniipbillapi.SimpleBillResponse>}
424
+ */
425
+ const methodInfo_SniipBillAPIService_CopyExistingBill = new grpc.web.AbstractClientBase.MethodInfo(
426
+ proto.sniipbillapi.SimpleBillResponse,
427
+ /**
428
+ * @param {!proto.sniipbillapi.CopyExistingBillRequest} request
429
+ * @return {!Uint8Array}
430
+ */
431
+ function(request) {
432
+ return request.serializeBinary();
433
+ },
434
+ proto.sniipbillapi.SimpleBillResponse.deserializeBinary
435
+ );
436
+
437
+
438
+ /**
439
+ * @param {!proto.sniipbillapi.CopyExistingBillRequest} request The
440
+ * request proto
441
+ * @param {?Object<string, string>} metadata User defined
442
+ * call metadata
443
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.SimpleBillResponse)}
444
+ * callback The callback function(error, response)
445
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.SimpleBillResponse>|undefined}
446
+ * The XHR Node Readable Stream
447
+ */
448
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.copyExistingBill =
449
+ function(request, metadata, callback) {
450
+ return this.client_.rpcCall(this.hostname_ +
451
+ '/sniipbillapi.SniipBillAPIService/CopyExistingBill',
452
+ request,
453
+ metadata || {},
454
+ methodDescriptor_SniipBillAPIService_CopyExistingBill,
455
+ callback);
456
+ };
457
+
458
+
459
+ /**
460
+ * @param {!proto.sniipbillapi.CopyExistingBillRequest} request The
461
+ * request proto
462
+ * @param {?Object<string, string>} metadata User defined
463
+ * call metadata
464
+ * @return {!Promise<!proto.sniipbillapi.SimpleBillResponse>}
465
+ * Promise that resolves to the response
466
+ */
467
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.copyExistingBill =
468
+ function(request, metadata) {
469
+ return this.client_.unaryCall(this.hostname_ +
470
+ '/sniipbillapi.SniipBillAPIService/CopyExistingBill',
471
+ request,
472
+ metadata || {},
473
+ methodDescriptor_SniipBillAPIService_CopyExistingBill);
474
+ };
475
+
476
+
477
+ /**
478
+ * @const
479
+ * @type {!grpc.web.MethodDescriptor<
480
+ * !proto.sniipbillapi.CreateBillRequest,
481
+ * !proto.sniipbillapi.BillCreateResponse>}
482
+ */
483
+ const methodDescriptor_SniipBillAPIService_CreateBill = new grpc.web.MethodDescriptor(
484
+ '/sniipbillapi.SniipBillAPIService/CreateBill',
485
+ grpc.web.MethodType.UNARY,
486
+ proto.sniipbillapi.CreateBillRequest,
487
+ proto.sniipbillapi.BillCreateResponse,
488
+ /**
489
+ * @param {!proto.sniipbillapi.CreateBillRequest} request
490
+ * @return {!Uint8Array}
491
+ */
492
+ function(request) {
493
+ return request.serializeBinary();
494
+ },
495
+ proto.sniipbillapi.BillCreateResponse.deserializeBinary
496
+ );
497
+
498
+
499
+ /**
500
+ * @const
501
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
502
+ * !proto.sniipbillapi.CreateBillRequest,
503
+ * !proto.sniipbillapi.BillCreateResponse>}
504
+ */
505
+ const methodInfo_SniipBillAPIService_CreateBill = new grpc.web.AbstractClientBase.MethodInfo(
506
+ proto.sniipbillapi.BillCreateResponse,
507
+ /**
508
+ * @param {!proto.sniipbillapi.CreateBillRequest} request
509
+ * @return {!Uint8Array}
510
+ */
511
+ function(request) {
512
+ return request.serializeBinary();
513
+ },
514
+ proto.sniipbillapi.BillCreateResponse.deserializeBinary
515
+ );
516
+
517
+
518
+ /**
519
+ * @param {!proto.sniipbillapi.CreateBillRequest} request The
520
+ * request proto
521
+ * @param {?Object<string, string>} metadata User defined
522
+ * call metadata
523
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillCreateResponse)}
524
+ * callback The callback function(error, response)
525
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillCreateResponse>|undefined}
526
+ * The XHR Node Readable Stream
527
+ */
528
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.createBill =
529
+ function(request, metadata, callback) {
530
+ return this.client_.rpcCall(this.hostname_ +
531
+ '/sniipbillapi.SniipBillAPIService/CreateBill',
532
+ request,
533
+ metadata || {},
534
+ methodDescriptor_SniipBillAPIService_CreateBill,
535
+ callback);
536
+ };
537
+
538
+
539
+ /**
540
+ * @param {!proto.sniipbillapi.CreateBillRequest} request The
541
+ * request proto
542
+ * @param {?Object<string, string>} metadata User defined
543
+ * call metadata
544
+ * @return {!Promise<!proto.sniipbillapi.BillCreateResponse>}
545
+ * Promise that resolves to the response
546
+ */
547
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.createBill =
548
+ function(request, metadata) {
549
+ return this.client_.unaryCall(this.hostname_ +
550
+ '/sniipbillapi.SniipBillAPIService/CreateBill',
551
+ request,
552
+ metadata || {},
553
+ methodDescriptor_SniipBillAPIService_CreateBill);
554
+ };
555
+
556
+
557
+ /**
558
+ * @const
559
+ * @type {!grpc.web.MethodDescriptor<
560
+ * !proto.sniipbillapi.CreateBillV2Request,
561
+ * !proto.sniipbillapi.BillCreateResponse>}
562
+ */
563
+ const methodDescriptor_SniipBillAPIService_CreateBillV2 = new grpc.web.MethodDescriptor(
564
+ '/sniipbillapi.SniipBillAPIService/CreateBillV2',
565
+ grpc.web.MethodType.UNARY,
566
+ proto.sniipbillapi.CreateBillV2Request,
567
+ proto.sniipbillapi.BillCreateResponse,
568
+ /**
569
+ * @param {!proto.sniipbillapi.CreateBillV2Request} request
570
+ * @return {!Uint8Array}
571
+ */
572
+ function(request) {
573
+ return request.serializeBinary();
574
+ },
575
+ proto.sniipbillapi.BillCreateResponse.deserializeBinary
576
+ );
577
+
578
+
579
+ /**
580
+ * @const
581
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
582
+ * !proto.sniipbillapi.CreateBillV2Request,
583
+ * !proto.sniipbillapi.BillCreateResponse>}
584
+ */
585
+ const methodInfo_SniipBillAPIService_CreateBillV2 = new grpc.web.AbstractClientBase.MethodInfo(
586
+ proto.sniipbillapi.BillCreateResponse,
587
+ /**
588
+ * @param {!proto.sniipbillapi.CreateBillV2Request} request
589
+ * @return {!Uint8Array}
590
+ */
591
+ function(request) {
592
+ return request.serializeBinary();
593
+ },
594
+ proto.sniipbillapi.BillCreateResponse.deserializeBinary
595
+ );
596
+
597
+
598
+ /**
599
+ * @param {!proto.sniipbillapi.CreateBillV2Request} request The
600
+ * request proto
601
+ * @param {?Object<string, string>} metadata User defined
602
+ * call metadata
603
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillCreateResponse)}
604
+ * callback The callback function(error, response)
605
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillCreateResponse>|undefined}
606
+ * The XHR Node Readable Stream
607
+ */
608
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.createBillV2 =
609
+ function(request, metadata, callback) {
610
+ return this.client_.rpcCall(this.hostname_ +
611
+ '/sniipbillapi.SniipBillAPIService/CreateBillV2',
612
+ request,
613
+ metadata || {},
614
+ methodDescriptor_SniipBillAPIService_CreateBillV2,
615
+ callback);
616
+ };
617
+
618
+
619
+ /**
620
+ * @param {!proto.sniipbillapi.CreateBillV2Request} request The
621
+ * request proto
622
+ * @param {?Object<string, string>} metadata User defined
623
+ * call metadata
624
+ * @return {!Promise<!proto.sniipbillapi.BillCreateResponse>}
625
+ * Promise that resolves to the response
626
+ */
627
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.createBillV2 =
628
+ function(request, metadata) {
629
+ return this.client_.unaryCall(this.hostname_ +
630
+ '/sniipbillapi.SniipBillAPIService/CreateBillV2',
631
+ request,
632
+ metadata || {},
633
+ methodDescriptor_SniipBillAPIService_CreateBillV2);
634
+ };
635
+
636
+
637
+ /**
638
+ * @const
639
+ * @type {!grpc.web.MethodDescriptor<
640
+ * !proto.sniipbillapi.CreateBillsRequest,
641
+ * !proto.sniipbillapi.BillsCreateResponse>}
642
+ */
643
+ const methodDescriptor_SniipBillAPIService_CreateBills = new grpc.web.MethodDescriptor(
644
+ '/sniipbillapi.SniipBillAPIService/CreateBills',
645
+ grpc.web.MethodType.UNARY,
646
+ proto.sniipbillapi.CreateBillsRequest,
647
+ proto.sniipbillapi.BillsCreateResponse,
648
+ /**
649
+ * @param {!proto.sniipbillapi.CreateBillsRequest} request
650
+ * @return {!Uint8Array}
651
+ */
652
+ function(request) {
653
+ return request.serializeBinary();
654
+ },
655
+ proto.sniipbillapi.BillsCreateResponse.deserializeBinary
656
+ );
657
+
658
+
659
+ /**
660
+ * @const
661
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
662
+ * !proto.sniipbillapi.CreateBillsRequest,
663
+ * !proto.sniipbillapi.BillsCreateResponse>}
664
+ */
665
+ const methodInfo_SniipBillAPIService_CreateBills = new grpc.web.AbstractClientBase.MethodInfo(
666
+ proto.sniipbillapi.BillsCreateResponse,
667
+ /**
668
+ * @param {!proto.sniipbillapi.CreateBillsRequest} request
669
+ * @return {!Uint8Array}
670
+ */
671
+ function(request) {
672
+ return request.serializeBinary();
673
+ },
674
+ proto.sniipbillapi.BillsCreateResponse.deserializeBinary
675
+ );
676
+
677
+
678
+ /**
679
+ * @param {!proto.sniipbillapi.CreateBillsRequest} request The
680
+ * request proto
681
+ * @param {?Object<string, string>} metadata User defined
682
+ * call metadata
683
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillsCreateResponse)}
684
+ * callback The callback function(error, response)
685
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillsCreateResponse>|undefined}
686
+ * The XHR Node Readable Stream
687
+ */
688
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.createBills =
689
+ function(request, metadata, callback) {
690
+ return this.client_.rpcCall(this.hostname_ +
691
+ '/sniipbillapi.SniipBillAPIService/CreateBills',
692
+ request,
693
+ metadata || {},
694
+ methodDescriptor_SniipBillAPIService_CreateBills,
695
+ callback);
696
+ };
697
+
698
+
699
+ /**
700
+ * @param {!proto.sniipbillapi.CreateBillsRequest} request The
701
+ * request proto
702
+ * @param {?Object<string, string>} metadata User defined
703
+ * call metadata
704
+ * @return {!Promise<!proto.sniipbillapi.BillsCreateResponse>}
705
+ * Promise that resolves to the response
706
+ */
707
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.createBills =
708
+ function(request, metadata) {
709
+ return this.client_.unaryCall(this.hostname_ +
710
+ '/sniipbillapi.SniipBillAPIService/CreateBills',
711
+ request,
712
+ metadata || {},
713
+ methodDescriptor_SniipBillAPIService_CreateBills);
714
+ };
715
+
716
+
717
+ /**
718
+ * @const
719
+ * @type {!grpc.web.MethodDescriptor<
720
+ * !proto.sniipbillapi.CreateDraftBillRequest,
721
+ * !proto.sniipbillapi.BillCreateResponse>}
722
+ */
723
+ const methodDescriptor_SniipBillAPIService_CreateDraftBill = new grpc.web.MethodDescriptor(
724
+ '/sniipbillapi.SniipBillAPIService/CreateDraftBill',
725
+ grpc.web.MethodType.UNARY,
726
+ proto.sniipbillapi.CreateDraftBillRequest,
727
+ proto.sniipbillapi.BillCreateResponse,
728
+ /**
729
+ * @param {!proto.sniipbillapi.CreateDraftBillRequest} request
730
+ * @return {!Uint8Array}
731
+ */
732
+ function(request) {
733
+ return request.serializeBinary();
734
+ },
735
+ proto.sniipbillapi.BillCreateResponse.deserializeBinary
736
+ );
737
+
738
+
739
+ /**
740
+ * @const
741
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
742
+ * !proto.sniipbillapi.CreateDraftBillRequest,
743
+ * !proto.sniipbillapi.BillCreateResponse>}
744
+ */
745
+ const methodInfo_SniipBillAPIService_CreateDraftBill = new grpc.web.AbstractClientBase.MethodInfo(
746
+ proto.sniipbillapi.BillCreateResponse,
747
+ /**
748
+ * @param {!proto.sniipbillapi.CreateDraftBillRequest} request
749
+ * @return {!Uint8Array}
750
+ */
751
+ function(request) {
752
+ return request.serializeBinary();
753
+ },
754
+ proto.sniipbillapi.BillCreateResponse.deserializeBinary
755
+ );
756
+
757
+
758
+ /**
759
+ * @param {!proto.sniipbillapi.CreateDraftBillRequest} request The
760
+ * request proto
761
+ * @param {?Object<string, string>} metadata User defined
762
+ * call metadata
763
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillCreateResponse)}
764
+ * callback The callback function(error, response)
765
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillCreateResponse>|undefined}
766
+ * The XHR Node Readable Stream
767
+ */
768
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.createDraftBill =
769
+ function(request, metadata, callback) {
770
+ return this.client_.rpcCall(this.hostname_ +
771
+ '/sniipbillapi.SniipBillAPIService/CreateDraftBill',
772
+ request,
773
+ metadata || {},
774
+ methodDescriptor_SniipBillAPIService_CreateDraftBill,
775
+ callback);
776
+ };
777
+
778
+
779
+ /**
780
+ * @param {!proto.sniipbillapi.CreateDraftBillRequest} request The
781
+ * request proto
782
+ * @param {?Object<string, string>} metadata User defined
783
+ * call metadata
784
+ * @return {!Promise<!proto.sniipbillapi.BillCreateResponse>}
785
+ * Promise that resolves to the response
786
+ */
787
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.createDraftBill =
788
+ function(request, metadata) {
789
+ return this.client_.unaryCall(this.hostname_ +
790
+ '/sniipbillapi.SniipBillAPIService/CreateDraftBill',
791
+ request,
792
+ metadata || {},
793
+ methodDescriptor_SniipBillAPIService_CreateDraftBill);
794
+ };
795
+
796
+
797
+ /**
798
+ * @const
799
+ * @type {!grpc.web.MethodDescriptor<
800
+ * !proto.sniipbillapi.CreateOrUpdateBillFromXeroInvoiceRequest,
801
+ * !proto.sniipbillapi.XeroCreateOrUpdateBillFromInvoiceResponse>}
802
+ */
803
+ const methodDescriptor_SniipBillAPIService_CreateOrUpdateBillFromXeroInvoice = new grpc.web.MethodDescriptor(
804
+ '/sniipbillapi.SniipBillAPIService/CreateOrUpdateBillFromXeroInvoice',
805
+ grpc.web.MethodType.UNARY,
806
+ proto.sniipbillapi.CreateOrUpdateBillFromXeroInvoiceRequest,
807
+ proto.sniipbillapi.XeroCreateOrUpdateBillFromInvoiceResponse,
808
+ /**
809
+ * @param {!proto.sniipbillapi.CreateOrUpdateBillFromXeroInvoiceRequest} request
810
+ * @return {!Uint8Array}
811
+ */
812
+ function(request) {
813
+ return request.serializeBinary();
814
+ },
815
+ proto.sniipbillapi.XeroCreateOrUpdateBillFromInvoiceResponse.deserializeBinary
816
+ );
817
+
818
+
819
+ /**
820
+ * @const
821
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
822
+ * !proto.sniipbillapi.CreateOrUpdateBillFromXeroInvoiceRequest,
823
+ * !proto.sniipbillapi.XeroCreateOrUpdateBillFromInvoiceResponse>}
824
+ */
825
+ const methodInfo_SniipBillAPIService_CreateOrUpdateBillFromXeroInvoice = new grpc.web.AbstractClientBase.MethodInfo(
826
+ proto.sniipbillapi.XeroCreateOrUpdateBillFromInvoiceResponse,
827
+ /**
828
+ * @param {!proto.sniipbillapi.CreateOrUpdateBillFromXeroInvoiceRequest} request
829
+ * @return {!Uint8Array}
830
+ */
831
+ function(request) {
832
+ return request.serializeBinary();
833
+ },
834
+ proto.sniipbillapi.XeroCreateOrUpdateBillFromInvoiceResponse.deserializeBinary
835
+ );
836
+
837
+
838
+ /**
839
+ * @param {!proto.sniipbillapi.CreateOrUpdateBillFromXeroInvoiceRequest} request The
840
+ * request proto
841
+ * @param {?Object<string, string>} metadata User defined
842
+ * call metadata
843
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.XeroCreateOrUpdateBillFromInvoiceResponse)}
844
+ * callback The callback function(error, response)
845
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.XeroCreateOrUpdateBillFromInvoiceResponse>|undefined}
846
+ * The XHR Node Readable Stream
847
+ */
848
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.createOrUpdateBillFromXeroInvoice =
849
+ function(request, metadata, callback) {
850
+ return this.client_.rpcCall(this.hostname_ +
851
+ '/sniipbillapi.SniipBillAPIService/CreateOrUpdateBillFromXeroInvoice',
852
+ request,
853
+ metadata || {},
854
+ methodDescriptor_SniipBillAPIService_CreateOrUpdateBillFromXeroInvoice,
855
+ callback);
856
+ };
857
+
858
+
859
+ /**
860
+ * @param {!proto.sniipbillapi.CreateOrUpdateBillFromXeroInvoiceRequest} request The
861
+ * request proto
862
+ * @param {?Object<string, string>} metadata User defined
863
+ * call metadata
864
+ * @return {!Promise<!proto.sniipbillapi.XeroCreateOrUpdateBillFromInvoiceResponse>}
865
+ * Promise that resolves to the response
866
+ */
867
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.createOrUpdateBillFromXeroInvoice =
868
+ function(request, metadata) {
869
+ return this.client_.unaryCall(this.hostname_ +
870
+ '/sniipbillapi.SniipBillAPIService/CreateOrUpdateBillFromXeroInvoice',
871
+ request,
872
+ metadata || {},
873
+ methodDescriptor_SniipBillAPIService_CreateOrUpdateBillFromXeroInvoice);
874
+ };
875
+
876
+
877
+ /**
878
+ * @const
879
+ * @type {!grpc.web.MethodDescriptor<
880
+ * !proto.sniipbillapi.DeleteBillRequest,
881
+ * !proto.sniipbillapi.ResponseCode>}
882
+ */
883
+ const methodDescriptor_SniipBillAPIService_DeleteBill = new grpc.web.MethodDescriptor(
884
+ '/sniipbillapi.SniipBillAPIService/DeleteBill',
885
+ grpc.web.MethodType.UNARY,
886
+ proto.sniipbillapi.DeleteBillRequest,
887
+ proto.sniipbillapi.ResponseCode,
888
+ /**
889
+ * @param {!proto.sniipbillapi.DeleteBillRequest} request
890
+ * @return {!Uint8Array}
891
+ */
892
+ function(request) {
893
+ return request.serializeBinary();
894
+ },
895
+ proto.sniipbillapi.ResponseCode.deserializeBinary
896
+ );
897
+
898
+
899
+ /**
900
+ * @const
901
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
902
+ * !proto.sniipbillapi.DeleteBillRequest,
903
+ * !proto.sniipbillapi.ResponseCode>}
904
+ */
905
+ const methodInfo_SniipBillAPIService_DeleteBill = new grpc.web.AbstractClientBase.MethodInfo(
906
+ proto.sniipbillapi.ResponseCode,
907
+ /**
908
+ * @param {!proto.sniipbillapi.DeleteBillRequest} request
909
+ * @return {!Uint8Array}
910
+ */
911
+ function(request) {
912
+ return request.serializeBinary();
913
+ },
914
+ proto.sniipbillapi.ResponseCode.deserializeBinary
915
+ );
916
+
917
+
918
+ /**
919
+ * @param {!proto.sniipbillapi.DeleteBillRequest} request The
920
+ * request proto
921
+ * @param {?Object<string, string>} metadata User defined
922
+ * call metadata
923
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
924
+ * callback The callback function(error, response)
925
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
926
+ * The XHR Node Readable Stream
927
+ */
928
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.deleteBill =
929
+ function(request, metadata, callback) {
930
+ return this.client_.rpcCall(this.hostname_ +
931
+ '/sniipbillapi.SniipBillAPIService/DeleteBill',
932
+ request,
933
+ metadata || {},
934
+ methodDescriptor_SniipBillAPIService_DeleteBill,
935
+ callback);
936
+ };
937
+
938
+
939
+ /**
940
+ * @param {!proto.sniipbillapi.DeleteBillRequest} request The
941
+ * request proto
942
+ * @param {?Object<string, string>} metadata User defined
943
+ * call metadata
944
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
945
+ * Promise that resolves to the response
946
+ */
947
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.deleteBill =
948
+ function(request, metadata) {
949
+ return this.client_.unaryCall(this.hostname_ +
950
+ '/sniipbillapi.SniipBillAPIService/DeleteBill',
951
+ request,
952
+ metadata || {},
953
+ methodDescriptor_SniipBillAPIService_DeleteBill);
954
+ };
955
+
956
+
957
+ /**
958
+ * @const
959
+ * @type {!grpc.web.MethodDescriptor<
960
+ * !proto.sniipbillapi.DeleteBillsRequest,
961
+ * !proto.sniipbillapi.ResponseCode>}
962
+ */
963
+ const methodDescriptor_SniipBillAPIService_DeleteBills = new grpc.web.MethodDescriptor(
964
+ '/sniipbillapi.SniipBillAPIService/DeleteBills',
965
+ grpc.web.MethodType.UNARY,
966
+ proto.sniipbillapi.DeleteBillsRequest,
967
+ proto.sniipbillapi.ResponseCode,
968
+ /**
969
+ * @param {!proto.sniipbillapi.DeleteBillsRequest} request
970
+ * @return {!Uint8Array}
971
+ */
972
+ function(request) {
973
+ return request.serializeBinary();
974
+ },
975
+ proto.sniipbillapi.ResponseCode.deserializeBinary
976
+ );
977
+
978
+
979
+ /**
980
+ * @const
981
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
982
+ * !proto.sniipbillapi.DeleteBillsRequest,
983
+ * !proto.sniipbillapi.ResponseCode>}
984
+ */
985
+ const methodInfo_SniipBillAPIService_DeleteBills = new grpc.web.AbstractClientBase.MethodInfo(
986
+ proto.sniipbillapi.ResponseCode,
987
+ /**
988
+ * @param {!proto.sniipbillapi.DeleteBillsRequest} request
989
+ * @return {!Uint8Array}
990
+ */
991
+ function(request) {
992
+ return request.serializeBinary();
993
+ },
994
+ proto.sniipbillapi.ResponseCode.deserializeBinary
995
+ );
996
+
997
+
998
+ /**
999
+ * @param {!proto.sniipbillapi.DeleteBillsRequest} request The
1000
+ * request proto
1001
+ * @param {?Object<string, string>} metadata User defined
1002
+ * call metadata
1003
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
1004
+ * callback The callback function(error, response)
1005
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
1006
+ * The XHR Node Readable Stream
1007
+ */
1008
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.deleteBills =
1009
+ function(request, metadata, callback) {
1010
+ return this.client_.rpcCall(this.hostname_ +
1011
+ '/sniipbillapi.SniipBillAPIService/DeleteBills',
1012
+ request,
1013
+ metadata || {},
1014
+ methodDescriptor_SniipBillAPIService_DeleteBills,
1015
+ callback);
1016
+ };
1017
+
1018
+
1019
+ /**
1020
+ * @param {!proto.sniipbillapi.DeleteBillsRequest} request The
1021
+ * request proto
1022
+ * @param {?Object<string, string>} metadata User defined
1023
+ * call metadata
1024
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
1025
+ * Promise that resolves to the response
1026
+ */
1027
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.deleteBills =
1028
+ function(request, metadata) {
1029
+ return this.client_.unaryCall(this.hostname_ +
1030
+ '/sniipbillapi.SniipBillAPIService/DeleteBills',
1031
+ request,
1032
+ metadata || {},
1033
+ methodDescriptor_SniipBillAPIService_DeleteBills);
1034
+ };
1035
+
1036
+
1037
+ /**
1038
+ * @const
1039
+ * @type {!grpc.web.MethodDescriptor<
1040
+ * !proto.sniipbillapi.ExcludeBillerReferenceRequest,
1041
+ * !proto.sniipbillapi.ResponseCode>}
1042
+ */
1043
+ const methodDescriptor_SniipBillAPIService_ExcludeBillerReference = new grpc.web.MethodDescriptor(
1044
+ '/sniipbillapi.SniipBillAPIService/ExcludeBillerReference',
1045
+ grpc.web.MethodType.UNARY,
1046
+ proto.sniipbillapi.ExcludeBillerReferenceRequest,
1047
+ proto.sniipbillapi.ResponseCode,
1048
+ /**
1049
+ * @param {!proto.sniipbillapi.ExcludeBillerReferenceRequest} request
1050
+ * @return {!Uint8Array}
1051
+ */
1052
+ function(request) {
1053
+ return request.serializeBinary();
1054
+ },
1055
+ proto.sniipbillapi.ResponseCode.deserializeBinary
1056
+ );
1057
+
1058
+
1059
+ /**
1060
+ * @const
1061
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1062
+ * !proto.sniipbillapi.ExcludeBillerReferenceRequest,
1063
+ * !proto.sniipbillapi.ResponseCode>}
1064
+ */
1065
+ const methodInfo_SniipBillAPIService_ExcludeBillerReference = new grpc.web.AbstractClientBase.MethodInfo(
1066
+ proto.sniipbillapi.ResponseCode,
1067
+ /**
1068
+ * @param {!proto.sniipbillapi.ExcludeBillerReferenceRequest} request
1069
+ * @return {!Uint8Array}
1070
+ */
1071
+ function(request) {
1072
+ return request.serializeBinary();
1073
+ },
1074
+ proto.sniipbillapi.ResponseCode.deserializeBinary
1075
+ );
1076
+
1077
+
1078
+ /**
1079
+ * @param {!proto.sniipbillapi.ExcludeBillerReferenceRequest} request The
1080
+ * request proto
1081
+ * @param {?Object<string, string>} metadata User defined
1082
+ * call metadata
1083
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
1084
+ * callback The callback function(error, response)
1085
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
1086
+ * The XHR Node Readable Stream
1087
+ */
1088
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.excludeBillerReference =
1089
+ function(request, metadata, callback) {
1090
+ return this.client_.rpcCall(this.hostname_ +
1091
+ '/sniipbillapi.SniipBillAPIService/ExcludeBillerReference',
1092
+ request,
1093
+ metadata || {},
1094
+ methodDescriptor_SniipBillAPIService_ExcludeBillerReference,
1095
+ callback);
1096
+ };
1097
+
1098
+
1099
+ /**
1100
+ * @param {!proto.sniipbillapi.ExcludeBillerReferenceRequest} request The
1101
+ * request proto
1102
+ * @param {?Object<string, string>} metadata User defined
1103
+ * call metadata
1104
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
1105
+ * Promise that resolves to the response
1106
+ */
1107
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.excludeBillerReference =
1108
+ function(request, metadata) {
1109
+ return this.client_.unaryCall(this.hostname_ +
1110
+ '/sniipbillapi.SniipBillAPIService/ExcludeBillerReference',
1111
+ request,
1112
+ metadata || {},
1113
+ methodDescriptor_SniipBillAPIService_ExcludeBillerReference);
1114
+ };
1115
+
1116
+
1117
+ /**
1118
+ * @const
1119
+ * @type {!grpc.web.MethodDescriptor<
1120
+ * !proto.sniipbillapi.FirstUserForBillersRequest,
1121
+ * !proto.sniipbillapi.FirstUserForBillersResponse>}
1122
+ */
1123
+ const methodDescriptor_SniipBillAPIService_FirstUserForBillers = new grpc.web.MethodDescriptor(
1124
+ '/sniipbillapi.SniipBillAPIService/FirstUserForBillers',
1125
+ grpc.web.MethodType.UNARY,
1126
+ proto.sniipbillapi.FirstUserForBillersRequest,
1127
+ proto.sniipbillapi.FirstUserForBillersResponse,
1128
+ /**
1129
+ * @param {!proto.sniipbillapi.FirstUserForBillersRequest} request
1130
+ * @return {!Uint8Array}
1131
+ */
1132
+ function(request) {
1133
+ return request.serializeBinary();
1134
+ },
1135
+ proto.sniipbillapi.FirstUserForBillersResponse.deserializeBinary
1136
+ );
1137
+
1138
+
1139
+ /**
1140
+ * @const
1141
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1142
+ * !proto.sniipbillapi.FirstUserForBillersRequest,
1143
+ * !proto.sniipbillapi.FirstUserForBillersResponse>}
1144
+ */
1145
+ const methodInfo_SniipBillAPIService_FirstUserForBillers = new grpc.web.AbstractClientBase.MethodInfo(
1146
+ proto.sniipbillapi.FirstUserForBillersResponse,
1147
+ /**
1148
+ * @param {!proto.sniipbillapi.FirstUserForBillersRequest} request
1149
+ * @return {!Uint8Array}
1150
+ */
1151
+ function(request) {
1152
+ return request.serializeBinary();
1153
+ },
1154
+ proto.sniipbillapi.FirstUserForBillersResponse.deserializeBinary
1155
+ );
1156
+
1157
+
1158
+ /**
1159
+ * @param {!proto.sniipbillapi.FirstUserForBillersRequest} request The
1160
+ * request proto
1161
+ * @param {?Object<string, string>} metadata User defined
1162
+ * call metadata
1163
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.FirstUserForBillersResponse)}
1164
+ * callback The callback function(error, response)
1165
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.FirstUserForBillersResponse>|undefined}
1166
+ * The XHR Node Readable Stream
1167
+ */
1168
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.firstUserForBillers =
1169
+ function(request, metadata, callback) {
1170
+ return this.client_.rpcCall(this.hostname_ +
1171
+ '/sniipbillapi.SniipBillAPIService/FirstUserForBillers',
1172
+ request,
1173
+ metadata || {},
1174
+ methodDescriptor_SniipBillAPIService_FirstUserForBillers,
1175
+ callback);
1176
+ };
1177
+
1178
+
1179
+ /**
1180
+ * @param {!proto.sniipbillapi.FirstUserForBillersRequest} request The
1181
+ * request proto
1182
+ * @param {?Object<string, string>} metadata User defined
1183
+ * call metadata
1184
+ * @return {!Promise<!proto.sniipbillapi.FirstUserForBillersResponse>}
1185
+ * Promise that resolves to the response
1186
+ */
1187
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.firstUserForBillers =
1188
+ function(request, metadata) {
1189
+ return this.client_.unaryCall(this.hostname_ +
1190
+ '/sniipbillapi.SniipBillAPIService/FirstUserForBillers',
1191
+ request,
1192
+ metadata || {},
1193
+ methodDescriptor_SniipBillAPIService_FirstUserForBillers);
1194
+ };
1195
+
1196
+
1197
+ /**
1198
+ * @const
1199
+ * @type {!grpc.web.MethodDescriptor<
1200
+ * !proto.sniipbillapi.GetBillAttachmentsByBillConfigIdsRequest,
1201
+ * !proto.sniipbillapi.BillsAttachmentsResponse>}
1202
+ */
1203
+ const methodDescriptor_SniipBillAPIService_GetBillAttachmentsByBillConfigIds = new grpc.web.MethodDescriptor(
1204
+ '/sniipbillapi.SniipBillAPIService/GetBillAttachmentsByBillConfigIds',
1205
+ grpc.web.MethodType.UNARY,
1206
+ proto.sniipbillapi.GetBillAttachmentsByBillConfigIdsRequest,
1207
+ proto.sniipbillapi.BillsAttachmentsResponse,
1208
+ /**
1209
+ * @param {!proto.sniipbillapi.GetBillAttachmentsByBillConfigIdsRequest} request
1210
+ * @return {!Uint8Array}
1211
+ */
1212
+ function(request) {
1213
+ return request.serializeBinary();
1214
+ },
1215
+ proto.sniipbillapi.BillsAttachmentsResponse.deserializeBinary
1216
+ );
1217
+
1218
+
1219
+ /**
1220
+ * @const
1221
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1222
+ * !proto.sniipbillapi.GetBillAttachmentsByBillConfigIdsRequest,
1223
+ * !proto.sniipbillapi.BillsAttachmentsResponse>}
1224
+ */
1225
+ const methodInfo_SniipBillAPIService_GetBillAttachmentsByBillConfigIds = new grpc.web.AbstractClientBase.MethodInfo(
1226
+ proto.sniipbillapi.BillsAttachmentsResponse,
1227
+ /**
1228
+ * @param {!proto.sniipbillapi.GetBillAttachmentsByBillConfigIdsRequest} request
1229
+ * @return {!Uint8Array}
1230
+ */
1231
+ function(request) {
1232
+ return request.serializeBinary();
1233
+ },
1234
+ proto.sniipbillapi.BillsAttachmentsResponse.deserializeBinary
1235
+ );
1236
+
1237
+
1238
+ /**
1239
+ * @param {!proto.sniipbillapi.GetBillAttachmentsByBillConfigIdsRequest} request The
1240
+ * request proto
1241
+ * @param {?Object<string, string>} metadata User defined
1242
+ * call metadata
1243
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillsAttachmentsResponse)}
1244
+ * callback The callback function(error, response)
1245
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillsAttachmentsResponse>|undefined}
1246
+ * The XHR Node Readable Stream
1247
+ */
1248
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getBillAttachmentsByBillConfigIds =
1249
+ function(request, metadata, callback) {
1250
+ return this.client_.rpcCall(this.hostname_ +
1251
+ '/sniipbillapi.SniipBillAPIService/GetBillAttachmentsByBillConfigIds',
1252
+ request,
1253
+ metadata || {},
1254
+ methodDescriptor_SniipBillAPIService_GetBillAttachmentsByBillConfigIds,
1255
+ callback);
1256
+ };
1257
+
1258
+
1259
+ /**
1260
+ * @param {!proto.sniipbillapi.GetBillAttachmentsByBillConfigIdsRequest} request The
1261
+ * request proto
1262
+ * @param {?Object<string, string>} metadata User defined
1263
+ * call metadata
1264
+ * @return {!Promise<!proto.sniipbillapi.BillsAttachmentsResponse>}
1265
+ * Promise that resolves to the response
1266
+ */
1267
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getBillAttachmentsByBillConfigIds =
1268
+ function(request, metadata) {
1269
+ return this.client_.unaryCall(this.hostname_ +
1270
+ '/sniipbillapi.SniipBillAPIService/GetBillAttachmentsByBillConfigIds',
1271
+ request,
1272
+ metadata || {},
1273
+ methodDescriptor_SniipBillAPIService_GetBillAttachmentsByBillConfigIds);
1274
+ };
1275
+
1276
+
1277
+ /**
1278
+ * @const
1279
+ * @type {!grpc.web.MethodDescriptor<
1280
+ * !proto.sniipbillapi.GetBillConfigsByBillIdsRequest,
1281
+ * !proto.sniipbillapi.BillConfigsResponse>}
1282
+ */
1283
+ const methodDescriptor_SniipBillAPIService_GetBillConfigsByBillIds = new grpc.web.MethodDescriptor(
1284
+ '/sniipbillapi.SniipBillAPIService/GetBillConfigsByBillIds',
1285
+ grpc.web.MethodType.UNARY,
1286
+ proto.sniipbillapi.GetBillConfigsByBillIdsRequest,
1287
+ proto.sniipbillapi.BillConfigsResponse,
1288
+ /**
1289
+ * @param {!proto.sniipbillapi.GetBillConfigsByBillIdsRequest} request
1290
+ * @return {!Uint8Array}
1291
+ */
1292
+ function(request) {
1293
+ return request.serializeBinary();
1294
+ },
1295
+ proto.sniipbillapi.BillConfigsResponse.deserializeBinary
1296
+ );
1297
+
1298
+
1299
+ /**
1300
+ * @const
1301
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1302
+ * !proto.sniipbillapi.GetBillConfigsByBillIdsRequest,
1303
+ * !proto.sniipbillapi.BillConfigsResponse>}
1304
+ */
1305
+ const methodInfo_SniipBillAPIService_GetBillConfigsByBillIds = new grpc.web.AbstractClientBase.MethodInfo(
1306
+ proto.sniipbillapi.BillConfigsResponse,
1307
+ /**
1308
+ * @param {!proto.sniipbillapi.GetBillConfigsByBillIdsRequest} request
1309
+ * @return {!Uint8Array}
1310
+ */
1311
+ function(request) {
1312
+ return request.serializeBinary();
1313
+ },
1314
+ proto.sniipbillapi.BillConfigsResponse.deserializeBinary
1315
+ );
1316
+
1317
+
1318
+ /**
1319
+ * @param {!proto.sniipbillapi.GetBillConfigsByBillIdsRequest} request The
1320
+ * request proto
1321
+ * @param {?Object<string, string>} metadata User defined
1322
+ * call metadata
1323
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillConfigsResponse)}
1324
+ * callback The callback function(error, response)
1325
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillConfigsResponse>|undefined}
1326
+ * The XHR Node Readable Stream
1327
+ */
1328
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getBillConfigsByBillIds =
1329
+ function(request, metadata, callback) {
1330
+ return this.client_.rpcCall(this.hostname_ +
1331
+ '/sniipbillapi.SniipBillAPIService/GetBillConfigsByBillIds',
1332
+ request,
1333
+ metadata || {},
1334
+ methodDescriptor_SniipBillAPIService_GetBillConfigsByBillIds,
1335
+ callback);
1336
+ };
1337
+
1338
+
1339
+ /**
1340
+ * @param {!proto.sniipbillapi.GetBillConfigsByBillIdsRequest} request The
1341
+ * request proto
1342
+ * @param {?Object<string, string>} metadata User defined
1343
+ * call metadata
1344
+ * @return {!Promise<!proto.sniipbillapi.BillConfigsResponse>}
1345
+ * Promise that resolves to the response
1346
+ */
1347
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getBillConfigsByBillIds =
1348
+ function(request, metadata) {
1349
+ return this.client_.unaryCall(this.hostname_ +
1350
+ '/sniipbillapi.SniipBillAPIService/GetBillConfigsByBillIds',
1351
+ request,
1352
+ metadata || {},
1353
+ methodDescriptor_SniipBillAPIService_GetBillConfigsByBillIds);
1354
+ };
1355
+
1356
+
1357
+ /**
1358
+ * @const
1359
+ * @type {!grpc.web.MethodDescriptor<
1360
+ * !proto.sniipbillapi.GetBillDetailsRequest,
1361
+ * !proto.sniipbillapi.BillDetails>}
1362
+ */
1363
+ const methodDescriptor_SniipBillAPIService_GetBillDetails = new grpc.web.MethodDescriptor(
1364
+ '/sniipbillapi.SniipBillAPIService/GetBillDetails',
1365
+ grpc.web.MethodType.UNARY,
1366
+ proto.sniipbillapi.GetBillDetailsRequest,
1367
+ proto.sniipbillapi.BillDetails,
1368
+ /**
1369
+ * @param {!proto.sniipbillapi.GetBillDetailsRequest} request
1370
+ * @return {!Uint8Array}
1371
+ */
1372
+ function(request) {
1373
+ return request.serializeBinary();
1374
+ },
1375
+ proto.sniipbillapi.BillDetails.deserializeBinary
1376
+ );
1377
+
1378
+
1379
+ /**
1380
+ * @const
1381
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1382
+ * !proto.sniipbillapi.GetBillDetailsRequest,
1383
+ * !proto.sniipbillapi.BillDetails>}
1384
+ */
1385
+ const methodInfo_SniipBillAPIService_GetBillDetails = new grpc.web.AbstractClientBase.MethodInfo(
1386
+ proto.sniipbillapi.BillDetails,
1387
+ /**
1388
+ * @param {!proto.sniipbillapi.GetBillDetailsRequest} request
1389
+ * @return {!Uint8Array}
1390
+ */
1391
+ function(request) {
1392
+ return request.serializeBinary();
1393
+ },
1394
+ proto.sniipbillapi.BillDetails.deserializeBinary
1395
+ );
1396
+
1397
+
1398
+ /**
1399
+ * @param {!proto.sniipbillapi.GetBillDetailsRequest} request The
1400
+ * request proto
1401
+ * @param {?Object<string, string>} metadata User defined
1402
+ * call metadata
1403
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillDetails)}
1404
+ * callback The callback function(error, response)
1405
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillDetails>|undefined}
1406
+ * The XHR Node Readable Stream
1407
+ */
1408
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getBillDetails =
1409
+ function(request, metadata, callback) {
1410
+ return this.client_.rpcCall(this.hostname_ +
1411
+ '/sniipbillapi.SniipBillAPIService/GetBillDetails',
1412
+ request,
1413
+ metadata || {},
1414
+ methodDescriptor_SniipBillAPIService_GetBillDetails,
1415
+ callback);
1416
+ };
1417
+
1418
+
1419
+ /**
1420
+ * @param {!proto.sniipbillapi.GetBillDetailsRequest} request The
1421
+ * request proto
1422
+ * @param {?Object<string, string>} metadata User defined
1423
+ * call metadata
1424
+ * @return {!Promise<!proto.sniipbillapi.BillDetails>}
1425
+ * Promise that resolves to the response
1426
+ */
1427
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getBillDetails =
1428
+ function(request, metadata) {
1429
+ return this.client_.unaryCall(this.hostname_ +
1430
+ '/sniipbillapi.SniipBillAPIService/GetBillDetails',
1431
+ request,
1432
+ metadata || {},
1433
+ methodDescriptor_SniipBillAPIService_GetBillDetails);
1434
+ };
1435
+
1436
+
1437
+ /**
1438
+ * @const
1439
+ * @type {!grpc.web.MethodDescriptor<
1440
+ * !proto.google.protobuf.Empty,
1441
+ * !proto.sniipbillapi.BillsSummaryResponse>}
1442
+ */
1443
+ const methodDescriptor_SniipBillAPIService_GetBillSummaryForUserDashboard = new grpc.web.MethodDescriptor(
1444
+ '/sniipbillapi.SniipBillAPIService/GetBillSummaryForUserDashboard',
1445
+ grpc.web.MethodType.UNARY,
1446
+ google_protobuf_empty_pb.Empty,
1447
+ proto.sniipbillapi.BillsSummaryResponse,
1448
+ /**
1449
+ * @param {!proto.google.protobuf.Empty} request
1450
+ * @return {!Uint8Array}
1451
+ */
1452
+ function(request) {
1453
+ return request.serializeBinary();
1454
+ },
1455
+ proto.sniipbillapi.BillsSummaryResponse.deserializeBinary
1456
+ );
1457
+
1458
+
1459
+ /**
1460
+ * @const
1461
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1462
+ * !proto.google.protobuf.Empty,
1463
+ * !proto.sniipbillapi.BillsSummaryResponse>}
1464
+ */
1465
+ const methodInfo_SniipBillAPIService_GetBillSummaryForUserDashboard = new grpc.web.AbstractClientBase.MethodInfo(
1466
+ proto.sniipbillapi.BillsSummaryResponse,
1467
+ /**
1468
+ * @param {!proto.google.protobuf.Empty} request
1469
+ * @return {!Uint8Array}
1470
+ */
1471
+ function(request) {
1472
+ return request.serializeBinary();
1473
+ },
1474
+ proto.sniipbillapi.BillsSummaryResponse.deserializeBinary
1475
+ );
1476
+
1477
+
1478
+ /**
1479
+ * @param {!proto.google.protobuf.Empty} request The
1480
+ * request proto
1481
+ * @param {?Object<string, string>} metadata User defined
1482
+ * call metadata
1483
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillsSummaryResponse)}
1484
+ * callback The callback function(error, response)
1485
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillsSummaryResponse>|undefined}
1486
+ * The XHR Node Readable Stream
1487
+ */
1488
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getBillSummaryForUserDashboard =
1489
+ function(request, metadata, callback) {
1490
+ return this.client_.rpcCall(this.hostname_ +
1491
+ '/sniipbillapi.SniipBillAPIService/GetBillSummaryForUserDashboard',
1492
+ request,
1493
+ metadata || {},
1494
+ methodDescriptor_SniipBillAPIService_GetBillSummaryForUserDashboard,
1495
+ callback);
1496
+ };
1497
+
1498
+
1499
+ /**
1500
+ * @param {!proto.google.protobuf.Empty} request The
1501
+ * request proto
1502
+ * @param {?Object<string, string>} metadata User defined
1503
+ * call metadata
1504
+ * @return {!Promise<!proto.sniipbillapi.BillsSummaryResponse>}
1505
+ * Promise that resolves to the response
1506
+ */
1507
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getBillSummaryForUserDashboard =
1508
+ function(request, metadata) {
1509
+ return this.client_.unaryCall(this.hostname_ +
1510
+ '/sniipbillapi.SniipBillAPIService/GetBillSummaryForUserDashboard',
1511
+ request,
1512
+ metadata || {},
1513
+ methodDescriptor_SniipBillAPIService_GetBillSummaryForUserDashboard);
1514
+ };
1515
+
1516
+
1517
+ /**
1518
+ * @const
1519
+ * @type {!grpc.web.MethodDescriptor<
1520
+ * !proto.sniipbillapi.GetBillsRequest,
1521
+ * !proto.sniipbillapi.BillsResponse>}
1522
+ */
1523
+ const methodDescriptor_SniipBillAPIService_GetBills = new grpc.web.MethodDescriptor(
1524
+ '/sniipbillapi.SniipBillAPIService/GetBills',
1525
+ grpc.web.MethodType.UNARY,
1526
+ proto.sniipbillapi.GetBillsRequest,
1527
+ proto.sniipbillapi.BillsResponse,
1528
+ /**
1529
+ * @param {!proto.sniipbillapi.GetBillsRequest} request
1530
+ * @return {!Uint8Array}
1531
+ */
1532
+ function(request) {
1533
+ return request.serializeBinary();
1534
+ },
1535
+ proto.sniipbillapi.BillsResponse.deserializeBinary
1536
+ );
1537
+
1538
+
1539
+ /**
1540
+ * @const
1541
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1542
+ * !proto.sniipbillapi.GetBillsRequest,
1543
+ * !proto.sniipbillapi.BillsResponse>}
1544
+ */
1545
+ const methodInfo_SniipBillAPIService_GetBills = new grpc.web.AbstractClientBase.MethodInfo(
1546
+ proto.sniipbillapi.BillsResponse,
1547
+ /**
1548
+ * @param {!proto.sniipbillapi.GetBillsRequest} request
1549
+ * @return {!Uint8Array}
1550
+ */
1551
+ function(request) {
1552
+ return request.serializeBinary();
1553
+ },
1554
+ proto.sniipbillapi.BillsResponse.deserializeBinary
1555
+ );
1556
+
1557
+
1558
+ /**
1559
+ * @param {!proto.sniipbillapi.GetBillsRequest} request The
1560
+ * request proto
1561
+ * @param {?Object<string, string>} metadata User defined
1562
+ * call metadata
1563
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillsResponse)}
1564
+ * callback The callback function(error, response)
1565
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillsResponse>|undefined}
1566
+ * The XHR Node Readable Stream
1567
+ */
1568
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getBills =
1569
+ function(request, metadata, callback) {
1570
+ return this.client_.rpcCall(this.hostname_ +
1571
+ '/sniipbillapi.SniipBillAPIService/GetBills',
1572
+ request,
1573
+ metadata || {},
1574
+ methodDescriptor_SniipBillAPIService_GetBills,
1575
+ callback);
1576
+ };
1577
+
1578
+
1579
+ /**
1580
+ * @param {!proto.sniipbillapi.GetBillsRequest} request The
1581
+ * request proto
1582
+ * @param {?Object<string, string>} metadata User defined
1583
+ * call metadata
1584
+ * @return {!Promise<!proto.sniipbillapi.BillsResponse>}
1585
+ * Promise that resolves to the response
1586
+ */
1587
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getBills =
1588
+ function(request, metadata) {
1589
+ return this.client_.unaryCall(this.hostname_ +
1590
+ '/sniipbillapi.SniipBillAPIService/GetBills',
1591
+ request,
1592
+ metadata || {},
1593
+ methodDescriptor_SniipBillAPIService_GetBills);
1594
+ };
1595
+
1596
+
1597
+ /**
1598
+ * @const
1599
+ * @type {!grpc.web.MethodDescriptor<
1600
+ * !proto.sniipbillapi.GetBillsByBillerIdAndUserIdRequest,
1601
+ * !proto.sniipbillapi.BillsResponse>}
1602
+ */
1603
+ const methodDescriptor_SniipBillAPIService_GetBillsByBillerIdAndUserId = new grpc.web.MethodDescriptor(
1604
+ '/sniipbillapi.SniipBillAPIService/GetBillsByBillerIdAndUserId',
1605
+ grpc.web.MethodType.UNARY,
1606
+ proto.sniipbillapi.GetBillsByBillerIdAndUserIdRequest,
1607
+ proto.sniipbillapi.BillsResponse,
1608
+ /**
1609
+ * @param {!proto.sniipbillapi.GetBillsByBillerIdAndUserIdRequest} request
1610
+ * @return {!Uint8Array}
1611
+ */
1612
+ function(request) {
1613
+ return request.serializeBinary();
1614
+ },
1615
+ proto.sniipbillapi.BillsResponse.deserializeBinary
1616
+ );
1617
+
1618
+
1619
+ /**
1620
+ * @const
1621
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1622
+ * !proto.sniipbillapi.GetBillsByBillerIdAndUserIdRequest,
1623
+ * !proto.sniipbillapi.BillsResponse>}
1624
+ */
1625
+ const methodInfo_SniipBillAPIService_GetBillsByBillerIdAndUserId = new grpc.web.AbstractClientBase.MethodInfo(
1626
+ proto.sniipbillapi.BillsResponse,
1627
+ /**
1628
+ * @param {!proto.sniipbillapi.GetBillsByBillerIdAndUserIdRequest} request
1629
+ * @return {!Uint8Array}
1630
+ */
1631
+ function(request) {
1632
+ return request.serializeBinary();
1633
+ },
1634
+ proto.sniipbillapi.BillsResponse.deserializeBinary
1635
+ );
1636
+
1637
+
1638
+ /**
1639
+ * @param {!proto.sniipbillapi.GetBillsByBillerIdAndUserIdRequest} request The
1640
+ * request proto
1641
+ * @param {?Object<string, string>} metadata User defined
1642
+ * call metadata
1643
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillsResponse)}
1644
+ * callback The callback function(error, response)
1645
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillsResponse>|undefined}
1646
+ * The XHR Node Readable Stream
1647
+ */
1648
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getBillsByBillerIdAndUserId =
1649
+ function(request, metadata, callback) {
1650
+ return this.client_.rpcCall(this.hostname_ +
1651
+ '/sniipbillapi.SniipBillAPIService/GetBillsByBillerIdAndUserId',
1652
+ request,
1653
+ metadata || {},
1654
+ methodDescriptor_SniipBillAPIService_GetBillsByBillerIdAndUserId,
1655
+ callback);
1656
+ };
1657
+
1658
+
1659
+ /**
1660
+ * @param {!proto.sniipbillapi.GetBillsByBillerIdAndUserIdRequest} request The
1661
+ * request proto
1662
+ * @param {?Object<string, string>} metadata User defined
1663
+ * call metadata
1664
+ * @return {!Promise<!proto.sniipbillapi.BillsResponse>}
1665
+ * Promise that resolves to the response
1666
+ */
1667
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getBillsByBillerIdAndUserId =
1668
+ function(request, metadata) {
1669
+ return this.client_.unaryCall(this.hostname_ +
1670
+ '/sniipbillapi.SniipBillAPIService/GetBillsByBillerIdAndUserId',
1671
+ request,
1672
+ metadata || {},
1673
+ methodDescriptor_SniipBillAPIService_GetBillsByBillerIdAndUserId);
1674
+ };
1675
+
1676
+
1677
+ /**
1678
+ * @const
1679
+ * @type {!grpc.web.MethodDescriptor<
1680
+ * !proto.sniipbillapi.GetBillsForUserRequest,
1681
+ * !proto.sniipbillapi.BillsResponse>}
1682
+ */
1683
+ const methodDescriptor_SniipBillAPIService_GetBillsForUser = new grpc.web.MethodDescriptor(
1684
+ '/sniipbillapi.SniipBillAPIService/GetBillsForUser',
1685
+ grpc.web.MethodType.UNARY,
1686
+ proto.sniipbillapi.GetBillsForUserRequest,
1687
+ proto.sniipbillapi.BillsResponse,
1688
+ /**
1689
+ * @param {!proto.sniipbillapi.GetBillsForUserRequest} request
1690
+ * @return {!Uint8Array}
1691
+ */
1692
+ function(request) {
1693
+ return request.serializeBinary();
1694
+ },
1695
+ proto.sniipbillapi.BillsResponse.deserializeBinary
1696
+ );
1697
+
1698
+
1699
+ /**
1700
+ * @const
1701
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1702
+ * !proto.sniipbillapi.GetBillsForUserRequest,
1703
+ * !proto.sniipbillapi.BillsResponse>}
1704
+ */
1705
+ const methodInfo_SniipBillAPIService_GetBillsForUser = new grpc.web.AbstractClientBase.MethodInfo(
1706
+ proto.sniipbillapi.BillsResponse,
1707
+ /**
1708
+ * @param {!proto.sniipbillapi.GetBillsForUserRequest} request
1709
+ * @return {!Uint8Array}
1710
+ */
1711
+ function(request) {
1712
+ return request.serializeBinary();
1713
+ },
1714
+ proto.sniipbillapi.BillsResponse.deserializeBinary
1715
+ );
1716
+
1717
+
1718
+ /**
1719
+ * @param {!proto.sniipbillapi.GetBillsForUserRequest} request The
1720
+ * request proto
1721
+ * @param {?Object<string, string>} metadata User defined
1722
+ * call metadata
1723
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillsResponse)}
1724
+ * callback The callback function(error, response)
1725
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillsResponse>|undefined}
1726
+ * The XHR Node Readable Stream
1727
+ */
1728
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getBillsForUser =
1729
+ function(request, metadata, callback) {
1730
+ return this.client_.rpcCall(this.hostname_ +
1731
+ '/sniipbillapi.SniipBillAPIService/GetBillsForUser',
1732
+ request,
1733
+ metadata || {},
1734
+ methodDescriptor_SniipBillAPIService_GetBillsForUser,
1735
+ callback);
1736
+ };
1737
+
1738
+
1739
+ /**
1740
+ * @param {!proto.sniipbillapi.GetBillsForUserRequest} request The
1741
+ * request proto
1742
+ * @param {?Object<string, string>} metadata User defined
1743
+ * call metadata
1744
+ * @return {!Promise<!proto.sniipbillapi.BillsResponse>}
1745
+ * Promise that resolves to the response
1746
+ */
1747
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getBillsForUser =
1748
+ function(request, metadata) {
1749
+ return this.client_.unaryCall(this.hostname_ +
1750
+ '/sniipbillapi.SniipBillAPIService/GetBillsForUser',
1751
+ request,
1752
+ metadata || {},
1753
+ methodDescriptor_SniipBillAPIService_GetBillsForUser);
1754
+ };
1755
+
1756
+
1757
+ /**
1758
+ * @const
1759
+ * @type {!grpc.web.MethodDescriptor<
1760
+ * !proto.sniipbillapi.GetBlockedOrganisationsForUserRequest,
1761
+ * !proto.sniipbillapi.BlockedOrganisationsForUserResponse>}
1762
+ */
1763
+ const methodDescriptor_SniipBillAPIService_GetBlockedOrganisationsForUser = new grpc.web.MethodDescriptor(
1764
+ '/sniipbillapi.SniipBillAPIService/GetBlockedOrganisationsForUser',
1765
+ grpc.web.MethodType.UNARY,
1766
+ proto.sniipbillapi.GetBlockedOrganisationsForUserRequest,
1767
+ proto.sniipbillapi.BlockedOrganisationsForUserResponse,
1768
+ /**
1769
+ * @param {!proto.sniipbillapi.GetBlockedOrganisationsForUserRequest} request
1770
+ * @return {!Uint8Array}
1771
+ */
1772
+ function(request) {
1773
+ return request.serializeBinary();
1774
+ },
1775
+ proto.sniipbillapi.BlockedOrganisationsForUserResponse.deserializeBinary
1776
+ );
1777
+
1778
+
1779
+ /**
1780
+ * @const
1781
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1782
+ * !proto.sniipbillapi.GetBlockedOrganisationsForUserRequest,
1783
+ * !proto.sniipbillapi.BlockedOrganisationsForUserResponse>}
1784
+ */
1785
+ const methodInfo_SniipBillAPIService_GetBlockedOrganisationsForUser = new grpc.web.AbstractClientBase.MethodInfo(
1786
+ proto.sniipbillapi.BlockedOrganisationsForUserResponse,
1787
+ /**
1788
+ * @param {!proto.sniipbillapi.GetBlockedOrganisationsForUserRequest} request
1789
+ * @return {!Uint8Array}
1790
+ */
1791
+ function(request) {
1792
+ return request.serializeBinary();
1793
+ },
1794
+ proto.sniipbillapi.BlockedOrganisationsForUserResponse.deserializeBinary
1795
+ );
1796
+
1797
+
1798
+ /**
1799
+ * @param {!proto.sniipbillapi.GetBlockedOrganisationsForUserRequest} request The
1800
+ * request proto
1801
+ * @param {?Object<string, string>} metadata User defined
1802
+ * call metadata
1803
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BlockedOrganisationsForUserResponse)}
1804
+ * callback The callback function(error, response)
1805
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BlockedOrganisationsForUserResponse>|undefined}
1806
+ * The XHR Node Readable Stream
1807
+ */
1808
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getBlockedOrganisationsForUser =
1809
+ function(request, metadata, callback) {
1810
+ return this.client_.rpcCall(this.hostname_ +
1811
+ '/sniipbillapi.SniipBillAPIService/GetBlockedOrganisationsForUser',
1812
+ request,
1813
+ metadata || {},
1814
+ methodDescriptor_SniipBillAPIService_GetBlockedOrganisationsForUser,
1815
+ callback);
1816
+ };
1817
+
1818
+
1819
+ /**
1820
+ * @param {!proto.sniipbillapi.GetBlockedOrganisationsForUserRequest} request The
1821
+ * request proto
1822
+ * @param {?Object<string, string>} metadata User defined
1823
+ * call metadata
1824
+ * @return {!Promise<!proto.sniipbillapi.BlockedOrganisationsForUserResponse>}
1825
+ * Promise that resolves to the response
1826
+ */
1827
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getBlockedOrganisationsForUser =
1828
+ function(request, metadata) {
1829
+ return this.client_.unaryCall(this.hostname_ +
1830
+ '/sniipbillapi.SniipBillAPIService/GetBlockedOrganisationsForUser',
1831
+ request,
1832
+ metadata || {},
1833
+ methodDescriptor_SniipBillAPIService_GetBlockedOrganisationsForUser);
1834
+ };
1835
+
1836
+
1837
+ /**
1838
+ * @const
1839
+ * @type {!grpc.web.MethodDescriptor<
1840
+ * !proto.sniipbillapi.GetDraftBillDetailsRequest,
1841
+ * !proto.sniipbillapi.DraftBillDetailsResponse>}
1842
+ */
1843
+ const methodDescriptor_SniipBillAPIService_GetDraftBillDetails = new grpc.web.MethodDescriptor(
1844
+ '/sniipbillapi.SniipBillAPIService/GetDraftBillDetails',
1845
+ grpc.web.MethodType.UNARY,
1846
+ proto.sniipbillapi.GetDraftBillDetailsRequest,
1847
+ proto.sniipbillapi.DraftBillDetailsResponse,
1848
+ /**
1849
+ * @param {!proto.sniipbillapi.GetDraftBillDetailsRequest} request
1850
+ * @return {!Uint8Array}
1851
+ */
1852
+ function(request) {
1853
+ return request.serializeBinary();
1854
+ },
1855
+ proto.sniipbillapi.DraftBillDetailsResponse.deserializeBinary
1856
+ );
1857
+
1858
+
1859
+ /**
1860
+ * @const
1861
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1862
+ * !proto.sniipbillapi.GetDraftBillDetailsRequest,
1863
+ * !proto.sniipbillapi.DraftBillDetailsResponse>}
1864
+ */
1865
+ const methodInfo_SniipBillAPIService_GetDraftBillDetails = new grpc.web.AbstractClientBase.MethodInfo(
1866
+ proto.sniipbillapi.DraftBillDetailsResponse,
1867
+ /**
1868
+ * @param {!proto.sniipbillapi.GetDraftBillDetailsRequest} request
1869
+ * @return {!Uint8Array}
1870
+ */
1871
+ function(request) {
1872
+ return request.serializeBinary();
1873
+ },
1874
+ proto.sniipbillapi.DraftBillDetailsResponse.deserializeBinary
1875
+ );
1876
+
1877
+
1878
+ /**
1879
+ * @param {!proto.sniipbillapi.GetDraftBillDetailsRequest} request The
1880
+ * request proto
1881
+ * @param {?Object<string, string>} metadata User defined
1882
+ * call metadata
1883
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.DraftBillDetailsResponse)}
1884
+ * callback The callback function(error, response)
1885
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.DraftBillDetailsResponse>|undefined}
1886
+ * The XHR Node Readable Stream
1887
+ */
1888
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getDraftBillDetails =
1889
+ function(request, metadata, callback) {
1890
+ return this.client_.rpcCall(this.hostname_ +
1891
+ '/sniipbillapi.SniipBillAPIService/GetDraftBillDetails',
1892
+ request,
1893
+ metadata || {},
1894
+ methodDescriptor_SniipBillAPIService_GetDraftBillDetails,
1895
+ callback);
1896
+ };
1897
+
1898
+
1899
+ /**
1900
+ * @param {!proto.sniipbillapi.GetDraftBillDetailsRequest} request The
1901
+ * request proto
1902
+ * @param {?Object<string, string>} metadata User defined
1903
+ * call metadata
1904
+ * @return {!Promise<!proto.sniipbillapi.DraftBillDetailsResponse>}
1905
+ * Promise that resolves to the response
1906
+ */
1907
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getDraftBillDetails =
1908
+ function(request, metadata) {
1909
+ return this.client_.unaryCall(this.hostname_ +
1910
+ '/sniipbillapi.SniipBillAPIService/GetDraftBillDetails',
1911
+ request,
1912
+ metadata || {},
1913
+ methodDescriptor_SniipBillAPIService_GetDraftBillDetails);
1914
+ };
1915
+
1916
+
1917
+ /**
1918
+ * @const
1919
+ * @type {!grpc.web.MethodDescriptor<
1920
+ * !proto.sniipbillapi.GetExistingBillRequest,
1921
+ * !proto.sniipbillapi.ExistingBillGetResponse>}
1922
+ */
1923
+ const methodDescriptor_SniipBillAPIService_GetExistingBill = new grpc.web.MethodDescriptor(
1924
+ '/sniipbillapi.SniipBillAPIService/GetExistingBill',
1925
+ grpc.web.MethodType.UNARY,
1926
+ proto.sniipbillapi.GetExistingBillRequest,
1927
+ proto.sniipbillapi.ExistingBillGetResponse,
1928
+ /**
1929
+ * @param {!proto.sniipbillapi.GetExistingBillRequest} request
1930
+ * @return {!Uint8Array}
1931
+ */
1932
+ function(request) {
1933
+ return request.serializeBinary();
1934
+ },
1935
+ proto.sniipbillapi.ExistingBillGetResponse.deserializeBinary
1936
+ );
1937
+
1938
+
1939
+ /**
1940
+ * @const
1941
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
1942
+ * !proto.sniipbillapi.GetExistingBillRequest,
1943
+ * !proto.sniipbillapi.ExistingBillGetResponse>}
1944
+ */
1945
+ const methodInfo_SniipBillAPIService_GetExistingBill = new grpc.web.AbstractClientBase.MethodInfo(
1946
+ proto.sniipbillapi.ExistingBillGetResponse,
1947
+ /**
1948
+ * @param {!proto.sniipbillapi.GetExistingBillRequest} request
1949
+ * @return {!Uint8Array}
1950
+ */
1951
+ function(request) {
1952
+ return request.serializeBinary();
1953
+ },
1954
+ proto.sniipbillapi.ExistingBillGetResponse.deserializeBinary
1955
+ );
1956
+
1957
+
1958
+ /**
1959
+ * @param {!proto.sniipbillapi.GetExistingBillRequest} request The
1960
+ * request proto
1961
+ * @param {?Object<string, string>} metadata User defined
1962
+ * call metadata
1963
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ExistingBillGetResponse)}
1964
+ * callback The callback function(error, response)
1965
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ExistingBillGetResponse>|undefined}
1966
+ * The XHR Node Readable Stream
1967
+ */
1968
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getExistingBill =
1969
+ function(request, metadata, callback) {
1970
+ return this.client_.rpcCall(this.hostname_ +
1971
+ '/sniipbillapi.SniipBillAPIService/GetExistingBill',
1972
+ request,
1973
+ metadata || {},
1974
+ methodDescriptor_SniipBillAPIService_GetExistingBill,
1975
+ callback);
1976
+ };
1977
+
1978
+
1979
+ /**
1980
+ * @param {!proto.sniipbillapi.GetExistingBillRequest} request The
1981
+ * request proto
1982
+ * @param {?Object<string, string>} metadata User defined
1983
+ * call metadata
1984
+ * @return {!Promise<!proto.sniipbillapi.ExistingBillGetResponse>}
1985
+ * Promise that resolves to the response
1986
+ */
1987
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getExistingBill =
1988
+ function(request, metadata) {
1989
+ return this.client_.unaryCall(this.hostname_ +
1990
+ '/sniipbillapi.SniipBillAPIService/GetExistingBill',
1991
+ request,
1992
+ metadata || {},
1993
+ methodDescriptor_SniipBillAPIService_GetExistingBill);
1994
+ };
1995
+
1996
+
1997
+ /**
1998
+ * @const
1999
+ * @type {!grpc.web.MethodDescriptor<
2000
+ * !proto.sniipbillapi.GetItemPaymentDetailsRequest,
2001
+ * !proto.sniipbillapi.ItemPaymentDetailsResponse>}
2002
+ */
2003
+ const methodDescriptor_SniipBillAPIService_GetItemPaymentDetails = new grpc.web.MethodDescriptor(
2004
+ '/sniipbillapi.SniipBillAPIService/GetItemPaymentDetails',
2005
+ grpc.web.MethodType.UNARY,
2006
+ proto.sniipbillapi.GetItemPaymentDetailsRequest,
2007
+ proto.sniipbillapi.ItemPaymentDetailsResponse,
2008
+ /**
2009
+ * @param {!proto.sniipbillapi.GetItemPaymentDetailsRequest} request
2010
+ * @return {!Uint8Array}
2011
+ */
2012
+ function(request) {
2013
+ return request.serializeBinary();
2014
+ },
2015
+ proto.sniipbillapi.ItemPaymentDetailsResponse.deserializeBinary
2016
+ );
2017
+
2018
+
2019
+ /**
2020
+ * @const
2021
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2022
+ * !proto.sniipbillapi.GetItemPaymentDetailsRequest,
2023
+ * !proto.sniipbillapi.ItemPaymentDetailsResponse>}
2024
+ */
2025
+ const methodInfo_SniipBillAPIService_GetItemPaymentDetails = new grpc.web.AbstractClientBase.MethodInfo(
2026
+ proto.sniipbillapi.ItemPaymentDetailsResponse,
2027
+ /**
2028
+ * @param {!proto.sniipbillapi.GetItemPaymentDetailsRequest} request
2029
+ * @return {!Uint8Array}
2030
+ */
2031
+ function(request) {
2032
+ return request.serializeBinary();
2033
+ },
2034
+ proto.sniipbillapi.ItemPaymentDetailsResponse.deserializeBinary
2035
+ );
2036
+
2037
+
2038
+ /**
2039
+ * @param {!proto.sniipbillapi.GetItemPaymentDetailsRequest} request The
2040
+ * request proto
2041
+ * @param {?Object<string, string>} metadata User defined
2042
+ * call metadata
2043
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ItemPaymentDetailsResponse)}
2044
+ * callback The callback function(error, response)
2045
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ItemPaymentDetailsResponse>|undefined}
2046
+ * The XHR Node Readable Stream
2047
+ */
2048
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getItemPaymentDetails =
2049
+ function(request, metadata, callback) {
2050
+ return this.client_.rpcCall(this.hostname_ +
2051
+ '/sniipbillapi.SniipBillAPIService/GetItemPaymentDetails',
2052
+ request,
2053
+ metadata || {},
2054
+ methodDescriptor_SniipBillAPIService_GetItemPaymentDetails,
2055
+ callback);
2056
+ };
2057
+
2058
+
2059
+ /**
2060
+ * @param {!proto.sniipbillapi.GetItemPaymentDetailsRequest} request The
2061
+ * request proto
2062
+ * @param {?Object<string, string>} metadata User defined
2063
+ * call metadata
2064
+ * @return {!Promise<!proto.sniipbillapi.ItemPaymentDetailsResponse>}
2065
+ * Promise that resolves to the response
2066
+ */
2067
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getItemPaymentDetails =
2068
+ function(request, metadata) {
2069
+ return this.client_.unaryCall(this.hostname_ +
2070
+ '/sniipbillapi.SniipBillAPIService/GetItemPaymentDetails',
2071
+ request,
2072
+ metadata || {},
2073
+ methodDescriptor_SniipBillAPIService_GetItemPaymentDetails);
2074
+ };
2075
+
2076
+
2077
+ /**
2078
+ * @const
2079
+ * @type {!grpc.web.MethodDescriptor<
2080
+ * !proto.sniipbillapi.GetItemPaymentDetailsInternalRequest,
2081
+ * !proto.sniipbillapi.ItemPaymentDetailsInternalResponse>}
2082
+ */
2083
+ const methodDescriptor_SniipBillAPIService_GetItemPaymentDetailsInternal = new grpc.web.MethodDescriptor(
2084
+ '/sniipbillapi.SniipBillAPIService/GetItemPaymentDetailsInternal',
2085
+ grpc.web.MethodType.UNARY,
2086
+ proto.sniipbillapi.GetItemPaymentDetailsInternalRequest,
2087
+ proto.sniipbillapi.ItemPaymentDetailsInternalResponse,
2088
+ /**
2089
+ * @param {!proto.sniipbillapi.GetItemPaymentDetailsInternalRequest} request
2090
+ * @return {!Uint8Array}
2091
+ */
2092
+ function(request) {
2093
+ return request.serializeBinary();
2094
+ },
2095
+ proto.sniipbillapi.ItemPaymentDetailsInternalResponse.deserializeBinary
2096
+ );
2097
+
2098
+
2099
+ /**
2100
+ * @const
2101
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2102
+ * !proto.sniipbillapi.GetItemPaymentDetailsInternalRequest,
2103
+ * !proto.sniipbillapi.ItemPaymentDetailsInternalResponse>}
2104
+ */
2105
+ const methodInfo_SniipBillAPIService_GetItemPaymentDetailsInternal = new grpc.web.AbstractClientBase.MethodInfo(
2106
+ proto.sniipbillapi.ItemPaymentDetailsInternalResponse,
2107
+ /**
2108
+ * @param {!proto.sniipbillapi.GetItemPaymentDetailsInternalRequest} request
2109
+ * @return {!Uint8Array}
2110
+ */
2111
+ function(request) {
2112
+ return request.serializeBinary();
2113
+ },
2114
+ proto.sniipbillapi.ItemPaymentDetailsInternalResponse.deserializeBinary
2115
+ );
2116
+
2117
+
2118
+ /**
2119
+ * @param {!proto.sniipbillapi.GetItemPaymentDetailsInternalRequest} request The
2120
+ * request proto
2121
+ * @param {?Object<string, string>} metadata User defined
2122
+ * call metadata
2123
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ItemPaymentDetailsInternalResponse)}
2124
+ * callback The callback function(error, response)
2125
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ItemPaymentDetailsInternalResponse>|undefined}
2126
+ * The XHR Node Readable Stream
2127
+ */
2128
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getItemPaymentDetailsInternal =
2129
+ function(request, metadata, callback) {
2130
+ return this.client_.rpcCall(this.hostname_ +
2131
+ '/sniipbillapi.SniipBillAPIService/GetItemPaymentDetailsInternal',
2132
+ request,
2133
+ metadata || {},
2134
+ methodDescriptor_SniipBillAPIService_GetItemPaymentDetailsInternal,
2135
+ callback);
2136
+ };
2137
+
2138
+
2139
+ /**
2140
+ * @param {!proto.sniipbillapi.GetItemPaymentDetailsInternalRequest} request The
2141
+ * request proto
2142
+ * @param {?Object<string, string>} metadata User defined
2143
+ * call metadata
2144
+ * @return {!Promise<!proto.sniipbillapi.ItemPaymentDetailsInternalResponse>}
2145
+ * Promise that resolves to the response
2146
+ */
2147
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getItemPaymentDetailsInternal =
2148
+ function(request, metadata) {
2149
+ return this.client_.unaryCall(this.hostname_ +
2150
+ '/sniipbillapi.SniipBillAPIService/GetItemPaymentDetailsInternal',
2151
+ request,
2152
+ metadata || {},
2153
+ methodDescriptor_SniipBillAPIService_GetItemPaymentDetailsInternal);
2154
+ };
2155
+
2156
+
2157
+ /**
2158
+ * @const
2159
+ * @type {!grpc.web.MethodDescriptor<
2160
+ * !proto.sniipbillapi.GetSimpleBillRequest,
2161
+ * !proto.sniipbillapi.SimpleBillResponse>}
2162
+ */
2163
+ const methodDescriptor_SniipBillAPIService_GetSimpleBill = new grpc.web.MethodDescriptor(
2164
+ '/sniipbillapi.SniipBillAPIService/GetSimpleBill',
2165
+ grpc.web.MethodType.UNARY,
2166
+ proto.sniipbillapi.GetSimpleBillRequest,
2167
+ proto.sniipbillapi.SimpleBillResponse,
2168
+ /**
2169
+ * @param {!proto.sniipbillapi.GetSimpleBillRequest} request
2170
+ * @return {!Uint8Array}
2171
+ */
2172
+ function(request) {
2173
+ return request.serializeBinary();
2174
+ },
2175
+ proto.sniipbillapi.SimpleBillResponse.deserializeBinary
2176
+ );
2177
+
2178
+
2179
+ /**
2180
+ * @const
2181
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2182
+ * !proto.sniipbillapi.GetSimpleBillRequest,
2183
+ * !proto.sniipbillapi.SimpleBillResponse>}
2184
+ */
2185
+ const methodInfo_SniipBillAPIService_GetSimpleBill = new grpc.web.AbstractClientBase.MethodInfo(
2186
+ proto.sniipbillapi.SimpleBillResponse,
2187
+ /**
2188
+ * @param {!proto.sniipbillapi.GetSimpleBillRequest} request
2189
+ * @return {!Uint8Array}
2190
+ */
2191
+ function(request) {
2192
+ return request.serializeBinary();
2193
+ },
2194
+ proto.sniipbillapi.SimpleBillResponse.deserializeBinary
2195
+ );
2196
+
2197
+
2198
+ /**
2199
+ * @param {!proto.sniipbillapi.GetSimpleBillRequest} request The
2200
+ * request proto
2201
+ * @param {?Object<string, string>} metadata User defined
2202
+ * call metadata
2203
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.SimpleBillResponse)}
2204
+ * callback The callback function(error, response)
2205
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.SimpleBillResponse>|undefined}
2206
+ * The XHR Node Readable Stream
2207
+ */
2208
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getSimpleBill =
2209
+ function(request, metadata, callback) {
2210
+ return this.client_.rpcCall(this.hostname_ +
2211
+ '/sniipbillapi.SniipBillAPIService/GetSimpleBill',
2212
+ request,
2213
+ metadata || {},
2214
+ methodDescriptor_SniipBillAPIService_GetSimpleBill,
2215
+ callback);
2216
+ };
2217
+
2218
+
2219
+ /**
2220
+ * @param {!proto.sniipbillapi.GetSimpleBillRequest} request The
2221
+ * request proto
2222
+ * @param {?Object<string, string>} metadata User defined
2223
+ * call metadata
2224
+ * @return {!Promise<!proto.sniipbillapi.SimpleBillResponse>}
2225
+ * Promise that resolves to the response
2226
+ */
2227
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getSimpleBill =
2228
+ function(request, metadata) {
2229
+ return this.client_.unaryCall(this.hostname_ +
2230
+ '/sniipbillapi.SniipBillAPIService/GetSimpleBill',
2231
+ request,
2232
+ metadata || {},
2233
+ methodDescriptor_SniipBillAPIService_GetSimpleBill);
2234
+ };
2235
+
2236
+
2237
+ /**
2238
+ * @const
2239
+ * @type {!grpc.web.MethodDescriptor<
2240
+ * !proto.sniipbillapi.GetToDoListRequest,
2241
+ * !proto.sniipbillapi.ToDoList>}
2242
+ */
2243
+ const methodDescriptor_SniipBillAPIService_GetToDoList = new grpc.web.MethodDescriptor(
2244
+ '/sniipbillapi.SniipBillAPIService/GetToDoList',
2245
+ grpc.web.MethodType.UNARY,
2246
+ proto.sniipbillapi.GetToDoListRequest,
2247
+ proto.sniipbillapi.ToDoList,
2248
+ /**
2249
+ * @param {!proto.sniipbillapi.GetToDoListRequest} request
2250
+ * @return {!Uint8Array}
2251
+ */
2252
+ function(request) {
2253
+ return request.serializeBinary();
2254
+ },
2255
+ proto.sniipbillapi.ToDoList.deserializeBinary
2256
+ );
2257
+
2258
+
2259
+ /**
2260
+ * @const
2261
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2262
+ * !proto.sniipbillapi.GetToDoListRequest,
2263
+ * !proto.sniipbillapi.ToDoList>}
2264
+ */
2265
+ const methodInfo_SniipBillAPIService_GetToDoList = new grpc.web.AbstractClientBase.MethodInfo(
2266
+ proto.sniipbillapi.ToDoList,
2267
+ /**
2268
+ * @param {!proto.sniipbillapi.GetToDoListRequest} request
2269
+ * @return {!Uint8Array}
2270
+ */
2271
+ function(request) {
2272
+ return request.serializeBinary();
2273
+ },
2274
+ proto.sniipbillapi.ToDoList.deserializeBinary
2275
+ );
2276
+
2277
+
2278
+ /**
2279
+ * @param {!proto.sniipbillapi.GetToDoListRequest} request The
2280
+ * request proto
2281
+ * @param {?Object<string, string>} metadata User defined
2282
+ * call metadata
2283
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ToDoList)}
2284
+ * callback The callback function(error, response)
2285
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ToDoList>|undefined}
2286
+ * The XHR Node Readable Stream
2287
+ */
2288
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getToDoList =
2289
+ function(request, metadata, callback) {
2290
+ return this.client_.rpcCall(this.hostname_ +
2291
+ '/sniipbillapi.SniipBillAPIService/GetToDoList',
2292
+ request,
2293
+ metadata || {},
2294
+ methodDescriptor_SniipBillAPIService_GetToDoList,
2295
+ callback);
2296
+ };
2297
+
2298
+
2299
+ /**
2300
+ * @param {!proto.sniipbillapi.GetToDoListRequest} request The
2301
+ * request proto
2302
+ * @param {?Object<string, string>} metadata User defined
2303
+ * call metadata
2304
+ * @return {!Promise<!proto.sniipbillapi.ToDoList>}
2305
+ * Promise that resolves to the response
2306
+ */
2307
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getToDoList =
2308
+ function(request, metadata) {
2309
+ return this.client_.unaryCall(this.hostname_ +
2310
+ '/sniipbillapi.SniipBillAPIService/GetToDoList',
2311
+ request,
2312
+ metadata || {},
2313
+ methodDescriptor_SniipBillAPIService_GetToDoList);
2314
+ };
2315
+
2316
+
2317
+ /**
2318
+ * @const
2319
+ * @type {!grpc.web.MethodDescriptor<
2320
+ * !proto.sniipbillapi.GetTodoRequest,
2321
+ * !proto.sniipbillapi.TodoResponse>}
2322
+ */
2323
+ const methodDescriptor_SniipBillAPIService_GetTodo = new grpc.web.MethodDescriptor(
2324
+ '/sniipbillapi.SniipBillAPIService/GetTodo',
2325
+ grpc.web.MethodType.UNARY,
2326
+ proto.sniipbillapi.GetTodoRequest,
2327
+ proto.sniipbillapi.TodoResponse,
2328
+ /**
2329
+ * @param {!proto.sniipbillapi.GetTodoRequest} request
2330
+ * @return {!Uint8Array}
2331
+ */
2332
+ function(request) {
2333
+ return request.serializeBinary();
2334
+ },
2335
+ proto.sniipbillapi.TodoResponse.deserializeBinary
2336
+ );
2337
+
2338
+
2339
+ /**
2340
+ * @const
2341
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2342
+ * !proto.sniipbillapi.GetTodoRequest,
2343
+ * !proto.sniipbillapi.TodoResponse>}
2344
+ */
2345
+ const methodInfo_SniipBillAPIService_GetTodo = new grpc.web.AbstractClientBase.MethodInfo(
2346
+ proto.sniipbillapi.TodoResponse,
2347
+ /**
2348
+ * @param {!proto.sniipbillapi.GetTodoRequest} request
2349
+ * @return {!Uint8Array}
2350
+ */
2351
+ function(request) {
2352
+ return request.serializeBinary();
2353
+ },
2354
+ proto.sniipbillapi.TodoResponse.deserializeBinary
2355
+ );
2356
+
2357
+
2358
+ /**
2359
+ * @param {!proto.sniipbillapi.GetTodoRequest} request The
2360
+ * request proto
2361
+ * @param {?Object<string, string>} metadata User defined
2362
+ * call metadata
2363
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.TodoResponse)}
2364
+ * callback The callback function(error, response)
2365
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.TodoResponse>|undefined}
2366
+ * The XHR Node Readable Stream
2367
+ */
2368
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getTodo =
2369
+ function(request, metadata, callback) {
2370
+ return this.client_.rpcCall(this.hostname_ +
2371
+ '/sniipbillapi.SniipBillAPIService/GetTodo',
2372
+ request,
2373
+ metadata || {},
2374
+ methodDescriptor_SniipBillAPIService_GetTodo,
2375
+ callback);
2376
+ };
2377
+
2378
+
2379
+ /**
2380
+ * @param {!proto.sniipbillapi.GetTodoRequest} request The
2381
+ * request proto
2382
+ * @param {?Object<string, string>} metadata User defined
2383
+ * call metadata
2384
+ * @return {!Promise<!proto.sniipbillapi.TodoResponse>}
2385
+ * Promise that resolves to the response
2386
+ */
2387
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getTodo =
2388
+ function(request, metadata) {
2389
+ return this.client_.unaryCall(this.hostname_ +
2390
+ '/sniipbillapi.SniipBillAPIService/GetTodo',
2391
+ request,
2392
+ metadata || {},
2393
+ methodDescriptor_SniipBillAPIService_GetTodo);
2394
+ };
2395
+
2396
+
2397
+ /**
2398
+ * @const
2399
+ * @type {!grpc.web.MethodDescriptor<
2400
+ * !proto.sniipbillapi.GetUnpaidMbillsRequest,
2401
+ * !proto.sniipbillapi.GetUnpaidMbillsResponse>}
2402
+ */
2403
+ const methodDescriptor_SniipBillAPIService_GetUnpaidMbills = new grpc.web.MethodDescriptor(
2404
+ '/sniipbillapi.SniipBillAPIService/GetUnpaidMbills',
2405
+ grpc.web.MethodType.UNARY,
2406
+ proto.sniipbillapi.GetUnpaidMbillsRequest,
2407
+ proto.sniipbillapi.GetUnpaidMbillsResponse,
2408
+ /**
2409
+ * @param {!proto.sniipbillapi.GetUnpaidMbillsRequest} request
2410
+ * @return {!Uint8Array}
2411
+ */
2412
+ function(request) {
2413
+ return request.serializeBinary();
2414
+ },
2415
+ proto.sniipbillapi.GetUnpaidMbillsResponse.deserializeBinary
2416
+ );
2417
+
2418
+
2419
+ /**
2420
+ * @const
2421
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2422
+ * !proto.sniipbillapi.GetUnpaidMbillsRequest,
2423
+ * !proto.sniipbillapi.GetUnpaidMbillsResponse>}
2424
+ */
2425
+ const methodInfo_SniipBillAPIService_GetUnpaidMbills = new grpc.web.AbstractClientBase.MethodInfo(
2426
+ proto.sniipbillapi.GetUnpaidMbillsResponse,
2427
+ /**
2428
+ * @param {!proto.sniipbillapi.GetUnpaidMbillsRequest} request
2429
+ * @return {!Uint8Array}
2430
+ */
2431
+ function(request) {
2432
+ return request.serializeBinary();
2433
+ },
2434
+ proto.sniipbillapi.GetUnpaidMbillsResponse.deserializeBinary
2435
+ );
2436
+
2437
+
2438
+ /**
2439
+ * @param {!proto.sniipbillapi.GetUnpaidMbillsRequest} request The
2440
+ * request proto
2441
+ * @param {?Object<string, string>} metadata User defined
2442
+ * call metadata
2443
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.GetUnpaidMbillsResponse)}
2444
+ * callback The callback function(error, response)
2445
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.GetUnpaidMbillsResponse>|undefined}
2446
+ * The XHR Node Readable Stream
2447
+ */
2448
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getUnpaidMbills =
2449
+ function(request, metadata, callback) {
2450
+ return this.client_.rpcCall(this.hostname_ +
2451
+ '/sniipbillapi.SniipBillAPIService/GetUnpaidMbills',
2452
+ request,
2453
+ metadata || {},
2454
+ methodDescriptor_SniipBillAPIService_GetUnpaidMbills,
2455
+ callback);
2456
+ };
2457
+
2458
+
2459
+ /**
2460
+ * @param {!proto.sniipbillapi.GetUnpaidMbillsRequest} request The
2461
+ * request proto
2462
+ * @param {?Object<string, string>} metadata User defined
2463
+ * call metadata
2464
+ * @return {!Promise<!proto.sniipbillapi.GetUnpaidMbillsResponse>}
2465
+ * Promise that resolves to the response
2466
+ */
2467
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getUnpaidMbills =
2468
+ function(request, metadata) {
2469
+ return this.client_.unaryCall(this.hostname_ +
2470
+ '/sniipbillapi.SniipBillAPIService/GetUnpaidMbills',
2471
+ request,
2472
+ metadata || {},
2473
+ methodDescriptor_SniipBillAPIService_GetUnpaidMbills);
2474
+ };
2475
+
2476
+
2477
+ /**
2478
+ * @const
2479
+ * @type {!grpc.web.MethodDescriptor<
2480
+ * !proto.google.protobuf.Empty,
2481
+ * !proto.sniipbillapi.UserBillConfigResponse>}
2482
+ */
2483
+ const methodDescriptor_SniipBillAPIService_GetUserBillConfig = new grpc.web.MethodDescriptor(
2484
+ '/sniipbillapi.SniipBillAPIService/GetUserBillConfig',
2485
+ grpc.web.MethodType.UNARY,
2486
+ google_protobuf_empty_pb.Empty,
2487
+ proto.sniipbillapi.UserBillConfigResponse,
2488
+ /**
2489
+ * @param {!proto.google.protobuf.Empty} request
2490
+ * @return {!Uint8Array}
2491
+ */
2492
+ function(request) {
2493
+ return request.serializeBinary();
2494
+ },
2495
+ proto.sniipbillapi.UserBillConfigResponse.deserializeBinary
2496
+ );
2497
+
2498
+
2499
+ /**
2500
+ * @const
2501
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2502
+ * !proto.google.protobuf.Empty,
2503
+ * !proto.sniipbillapi.UserBillConfigResponse>}
2504
+ */
2505
+ const methodInfo_SniipBillAPIService_GetUserBillConfig = new grpc.web.AbstractClientBase.MethodInfo(
2506
+ proto.sniipbillapi.UserBillConfigResponse,
2507
+ /**
2508
+ * @param {!proto.google.protobuf.Empty} request
2509
+ * @return {!Uint8Array}
2510
+ */
2511
+ function(request) {
2512
+ return request.serializeBinary();
2513
+ },
2514
+ proto.sniipbillapi.UserBillConfigResponse.deserializeBinary
2515
+ );
2516
+
2517
+
2518
+ /**
2519
+ * @param {!proto.google.protobuf.Empty} request The
2520
+ * request proto
2521
+ * @param {?Object<string, string>} metadata User defined
2522
+ * call metadata
2523
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.UserBillConfigResponse)}
2524
+ * callback The callback function(error, response)
2525
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.UserBillConfigResponse>|undefined}
2526
+ * The XHR Node Readable Stream
2527
+ */
2528
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getUserBillConfig =
2529
+ function(request, metadata, callback) {
2530
+ return this.client_.rpcCall(this.hostname_ +
2531
+ '/sniipbillapi.SniipBillAPIService/GetUserBillConfig',
2532
+ request,
2533
+ metadata || {},
2534
+ methodDescriptor_SniipBillAPIService_GetUserBillConfig,
2535
+ callback);
2536
+ };
2537
+
2538
+
2539
+ /**
2540
+ * @param {!proto.google.protobuf.Empty} request The
2541
+ * request proto
2542
+ * @param {?Object<string, string>} metadata User defined
2543
+ * call metadata
2544
+ * @return {!Promise<!proto.sniipbillapi.UserBillConfigResponse>}
2545
+ * Promise that resolves to the response
2546
+ */
2547
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getUserBillConfig =
2548
+ function(request, metadata) {
2549
+ return this.client_.unaryCall(this.hostname_ +
2550
+ '/sniipbillapi.SniipBillAPIService/GetUserBillConfig',
2551
+ request,
2552
+ metadata || {},
2553
+ methodDescriptor_SniipBillAPIService_GetUserBillConfig);
2554
+ };
2555
+
2556
+
2557
+ /**
2558
+ * @const
2559
+ * @type {!grpc.web.MethodDescriptor<
2560
+ * !proto.sniipbillapi.GetUserBillDetailsRequest,
2561
+ * !proto.sniipbillapi.BillDetailsResponse>}
2562
+ */
2563
+ const methodDescriptor_SniipBillAPIService_GetUserBillDetails = new grpc.web.MethodDescriptor(
2564
+ '/sniipbillapi.SniipBillAPIService/GetUserBillDetails',
2565
+ grpc.web.MethodType.UNARY,
2566
+ proto.sniipbillapi.GetUserBillDetailsRequest,
2567
+ proto.sniipbillapi.BillDetailsResponse,
2568
+ /**
2569
+ * @param {!proto.sniipbillapi.GetUserBillDetailsRequest} request
2570
+ * @return {!Uint8Array}
2571
+ */
2572
+ function(request) {
2573
+ return request.serializeBinary();
2574
+ },
2575
+ proto.sniipbillapi.BillDetailsResponse.deserializeBinary
2576
+ );
2577
+
2578
+
2579
+ /**
2580
+ * @const
2581
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2582
+ * !proto.sniipbillapi.GetUserBillDetailsRequest,
2583
+ * !proto.sniipbillapi.BillDetailsResponse>}
2584
+ */
2585
+ const methodInfo_SniipBillAPIService_GetUserBillDetails = new grpc.web.AbstractClientBase.MethodInfo(
2586
+ proto.sniipbillapi.BillDetailsResponse,
2587
+ /**
2588
+ * @param {!proto.sniipbillapi.GetUserBillDetailsRequest} request
2589
+ * @return {!Uint8Array}
2590
+ */
2591
+ function(request) {
2592
+ return request.serializeBinary();
2593
+ },
2594
+ proto.sniipbillapi.BillDetailsResponse.deserializeBinary
2595
+ );
2596
+
2597
+
2598
+ /**
2599
+ * @param {!proto.sniipbillapi.GetUserBillDetailsRequest} request The
2600
+ * request proto
2601
+ * @param {?Object<string, string>} metadata User defined
2602
+ * call metadata
2603
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillDetailsResponse)}
2604
+ * callback The callback function(error, response)
2605
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillDetailsResponse>|undefined}
2606
+ * The XHR Node Readable Stream
2607
+ */
2608
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getUserBillDetails =
2609
+ function(request, metadata, callback) {
2610
+ return this.client_.rpcCall(this.hostname_ +
2611
+ '/sniipbillapi.SniipBillAPIService/GetUserBillDetails',
2612
+ request,
2613
+ metadata || {},
2614
+ methodDescriptor_SniipBillAPIService_GetUserBillDetails,
2615
+ callback);
2616
+ };
2617
+
2618
+
2619
+ /**
2620
+ * @param {!proto.sniipbillapi.GetUserBillDetailsRequest} request The
2621
+ * request proto
2622
+ * @param {?Object<string, string>} metadata User defined
2623
+ * call metadata
2624
+ * @return {!Promise<!proto.sniipbillapi.BillDetailsResponse>}
2625
+ * Promise that resolves to the response
2626
+ */
2627
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getUserBillDetails =
2628
+ function(request, metadata) {
2629
+ return this.client_.unaryCall(this.hostname_ +
2630
+ '/sniipbillapi.SniipBillAPIService/GetUserBillDetails',
2631
+ request,
2632
+ metadata || {},
2633
+ methodDescriptor_SniipBillAPIService_GetUserBillDetails);
2634
+ };
2635
+
2636
+
2637
+ /**
2638
+ * @const
2639
+ * @type {!grpc.web.MethodDescriptor<
2640
+ * !proto.sniipbillapi.GetUserBillsRequest,
2641
+ * !proto.sniipbillapi.UserBillListResponse>}
2642
+ */
2643
+ const methodDescriptor_SniipBillAPIService_GetUserBills = new grpc.web.MethodDescriptor(
2644
+ '/sniipbillapi.SniipBillAPIService/GetUserBills',
2645
+ grpc.web.MethodType.UNARY,
2646
+ proto.sniipbillapi.GetUserBillsRequest,
2647
+ proto.sniipbillapi.UserBillListResponse,
2648
+ /**
2649
+ * @param {!proto.sniipbillapi.GetUserBillsRequest} request
2650
+ * @return {!Uint8Array}
2651
+ */
2652
+ function(request) {
2653
+ return request.serializeBinary();
2654
+ },
2655
+ proto.sniipbillapi.UserBillListResponse.deserializeBinary
2656
+ );
2657
+
2658
+
2659
+ /**
2660
+ * @const
2661
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2662
+ * !proto.sniipbillapi.GetUserBillsRequest,
2663
+ * !proto.sniipbillapi.UserBillListResponse>}
2664
+ */
2665
+ const methodInfo_SniipBillAPIService_GetUserBills = new grpc.web.AbstractClientBase.MethodInfo(
2666
+ proto.sniipbillapi.UserBillListResponse,
2667
+ /**
2668
+ * @param {!proto.sniipbillapi.GetUserBillsRequest} request
2669
+ * @return {!Uint8Array}
2670
+ */
2671
+ function(request) {
2672
+ return request.serializeBinary();
2673
+ },
2674
+ proto.sniipbillapi.UserBillListResponse.deserializeBinary
2675
+ );
2676
+
2677
+
2678
+ /**
2679
+ * @param {!proto.sniipbillapi.GetUserBillsRequest} request The
2680
+ * request proto
2681
+ * @param {?Object<string, string>} metadata User defined
2682
+ * call metadata
2683
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.UserBillListResponse)}
2684
+ * callback The callback function(error, response)
2685
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.UserBillListResponse>|undefined}
2686
+ * The XHR Node Readable Stream
2687
+ */
2688
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.getUserBills =
2689
+ function(request, metadata, callback) {
2690
+ return this.client_.rpcCall(this.hostname_ +
2691
+ '/sniipbillapi.SniipBillAPIService/GetUserBills',
2692
+ request,
2693
+ metadata || {},
2694
+ methodDescriptor_SniipBillAPIService_GetUserBills,
2695
+ callback);
2696
+ };
2697
+
2698
+
2699
+ /**
2700
+ * @param {!proto.sniipbillapi.GetUserBillsRequest} request The
2701
+ * request proto
2702
+ * @param {?Object<string, string>} metadata User defined
2703
+ * call metadata
2704
+ * @return {!Promise<!proto.sniipbillapi.UserBillListResponse>}
2705
+ * Promise that resolves to the response
2706
+ */
2707
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.getUserBills =
2708
+ function(request, metadata) {
2709
+ return this.client_.unaryCall(this.hostname_ +
2710
+ '/sniipbillapi.SniipBillAPIService/GetUserBills',
2711
+ request,
2712
+ metadata || {},
2713
+ methodDescriptor_SniipBillAPIService_GetUserBills);
2714
+ };
2715
+
2716
+
2717
+ /**
2718
+ * @const
2719
+ * @type {!grpc.web.MethodDescriptor<
2720
+ * !proto.sniipbillapi.IsBillLockedRequest,
2721
+ * !proto.sniipbillapi.BillLockedResponse>}
2722
+ */
2723
+ const methodDescriptor_SniipBillAPIService_IsBillLocked = new grpc.web.MethodDescriptor(
2724
+ '/sniipbillapi.SniipBillAPIService/IsBillLocked',
2725
+ grpc.web.MethodType.UNARY,
2726
+ proto.sniipbillapi.IsBillLockedRequest,
2727
+ proto.sniipbillapi.BillLockedResponse,
2728
+ /**
2729
+ * @param {!proto.sniipbillapi.IsBillLockedRequest} request
2730
+ * @return {!Uint8Array}
2731
+ */
2732
+ function(request) {
2733
+ return request.serializeBinary();
2734
+ },
2735
+ proto.sniipbillapi.BillLockedResponse.deserializeBinary
2736
+ );
2737
+
2738
+
2739
+ /**
2740
+ * @const
2741
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2742
+ * !proto.sniipbillapi.IsBillLockedRequest,
2743
+ * !proto.sniipbillapi.BillLockedResponse>}
2744
+ */
2745
+ const methodInfo_SniipBillAPIService_IsBillLocked = new grpc.web.AbstractClientBase.MethodInfo(
2746
+ proto.sniipbillapi.BillLockedResponse,
2747
+ /**
2748
+ * @param {!proto.sniipbillapi.IsBillLockedRequest} request
2749
+ * @return {!Uint8Array}
2750
+ */
2751
+ function(request) {
2752
+ return request.serializeBinary();
2753
+ },
2754
+ proto.sniipbillapi.BillLockedResponse.deserializeBinary
2755
+ );
2756
+
2757
+
2758
+ /**
2759
+ * @param {!proto.sniipbillapi.IsBillLockedRequest} request The
2760
+ * request proto
2761
+ * @param {?Object<string, string>} metadata User defined
2762
+ * call metadata
2763
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillLockedResponse)}
2764
+ * callback The callback function(error, response)
2765
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillLockedResponse>|undefined}
2766
+ * The XHR Node Readable Stream
2767
+ */
2768
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.isBillLocked =
2769
+ function(request, metadata, callback) {
2770
+ return this.client_.rpcCall(this.hostname_ +
2771
+ '/sniipbillapi.SniipBillAPIService/IsBillLocked',
2772
+ request,
2773
+ metadata || {},
2774
+ methodDescriptor_SniipBillAPIService_IsBillLocked,
2775
+ callback);
2776
+ };
2777
+
2778
+
2779
+ /**
2780
+ * @param {!proto.sniipbillapi.IsBillLockedRequest} request The
2781
+ * request proto
2782
+ * @param {?Object<string, string>} metadata User defined
2783
+ * call metadata
2784
+ * @return {!Promise<!proto.sniipbillapi.BillLockedResponse>}
2785
+ * Promise that resolves to the response
2786
+ */
2787
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.isBillLocked =
2788
+ function(request, metadata) {
2789
+ return this.client_.unaryCall(this.hostname_ +
2790
+ '/sniipbillapi.SniipBillAPIService/IsBillLocked',
2791
+ request,
2792
+ metadata || {},
2793
+ methodDescriptor_SniipBillAPIService_IsBillLocked);
2794
+ };
2795
+
2796
+
2797
+ /**
2798
+ * @const
2799
+ * @type {!grpc.web.MethodDescriptor<
2800
+ * !proto.sniipbillapi.LinkAnonymousBillRequest,
2801
+ * !proto.sniipbillapi.LinkedAnomymousBillResponse>}
2802
+ */
2803
+ const methodDescriptor_SniipBillAPIService_LinkAnonymousBill = new grpc.web.MethodDescriptor(
2804
+ '/sniipbillapi.SniipBillAPIService/LinkAnonymousBill',
2805
+ grpc.web.MethodType.UNARY,
2806
+ proto.sniipbillapi.LinkAnonymousBillRequest,
2807
+ proto.sniipbillapi.LinkedAnomymousBillResponse,
2808
+ /**
2809
+ * @param {!proto.sniipbillapi.LinkAnonymousBillRequest} request
2810
+ * @return {!Uint8Array}
2811
+ */
2812
+ function(request) {
2813
+ return request.serializeBinary();
2814
+ },
2815
+ proto.sniipbillapi.LinkedAnomymousBillResponse.deserializeBinary
2816
+ );
2817
+
2818
+
2819
+ /**
2820
+ * @const
2821
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2822
+ * !proto.sniipbillapi.LinkAnonymousBillRequest,
2823
+ * !proto.sniipbillapi.LinkedAnomymousBillResponse>}
2824
+ */
2825
+ const methodInfo_SniipBillAPIService_LinkAnonymousBill = new grpc.web.AbstractClientBase.MethodInfo(
2826
+ proto.sniipbillapi.LinkedAnomymousBillResponse,
2827
+ /**
2828
+ * @param {!proto.sniipbillapi.LinkAnonymousBillRequest} request
2829
+ * @return {!Uint8Array}
2830
+ */
2831
+ function(request) {
2832
+ return request.serializeBinary();
2833
+ },
2834
+ proto.sniipbillapi.LinkedAnomymousBillResponse.deserializeBinary
2835
+ );
2836
+
2837
+
2838
+ /**
2839
+ * @param {!proto.sniipbillapi.LinkAnonymousBillRequest} request The
2840
+ * request proto
2841
+ * @param {?Object<string, string>} metadata User defined
2842
+ * call metadata
2843
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.LinkedAnomymousBillResponse)}
2844
+ * callback The callback function(error, response)
2845
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.LinkedAnomymousBillResponse>|undefined}
2846
+ * The XHR Node Readable Stream
2847
+ */
2848
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.linkAnonymousBill =
2849
+ function(request, metadata, callback) {
2850
+ return this.client_.rpcCall(this.hostname_ +
2851
+ '/sniipbillapi.SniipBillAPIService/LinkAnonymousBill',
2852
+ request,
2853
+ metadata || {},
2854
+ methodDescriptor_SniipBillAPIService_LinkAnonymousBill,
2855
+ callback);
2856
+ };
2857
+
2858
+
2859
+ /**
2860
+ * @param {!proto.sniipbillapi.LinkAnonymousBillRequest} request The
2861
+ * request proto
2862
+ * @param {?Object<string, string>} metadata User defined
2863
+ * call metadata
2864
+ * @return {!Promise<!proto.sniipbillapi.LinkedAnomymousBillResponse>}
2865
+ * Promise that resolves to the response
2866
+ */
2867
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.linkAnonymousBill =
2868
+ function(request, metadata) {
2869
+ return this.client_.unaryCall(this.hostname_ +
2870
+ '/sniipbillapi.SniipBillAPIService/LinkAnonymousBill',
2871
+ request,
2872
+ metadata || {},
2873
+ methodDescriptor_SniipBillAPIService_LinkAnonymousBill);
2874
+ };
2875
+
2876
+
2877
+ /**
2878
+ * @const
2879
+ * @type {!grpc.web.MethodDescriptor<
2880
+ * !proto.sniipbillapi.LockBillRequest,
2881
+ * !proto.sniipbillapi.ResponseCode>}
2882
+ */
2883
+ const methodDescriptor_SniipBillAPIService_LockBill = new grpc.web.MethodDescriptor(
2884
+ '/sniipbillapi.SniipBillAPIService/LockBill',
2885
+ grpc.web.MethodType.UNARY,
2886
+ proto.sniipbillapi.LockBillRequest,
2887
+ proto.sniipbillapi.ResponseCode,
2888
+ /**
2889
+ * @param {!proto.sniipbillapi.LockBillRequest} request
2890
+ * @return {!Uint8Array}
2891
+ */
2892
+ function(request) {
2893
+ return request.serializeBinary();
2894
+ },
2895
+ proto.sniipbillapi.ResponseCode.deserializeBinary
2896
+ );
2897
+
2898
+
2899
+ /**
2900
+ * @const
2901
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2902
+ * !proto.sniipbillapi.LockBillRequest,
2903
+ * !proto.sniipbillapi.ResponseCode>}
2904
+ */
2905
+ const methodInfo_SniipBillAPIService_LockBill = new grpc.web.AbstractClientBase.MethodInfo(
2906
+ proto.sniipbillapi.ResponseCode,
2907
+ /**
2908
+ * @param {!proto.sniipbillapi.LockBillRequest} request
2909
+ * @return {!Uint8Array}
2910
+ */
2911
+ function(request) {
2912
+ return request.serializeBinary();
2913
+ },
2914
+ proto.sniipbillapi.ResponseCode.deserializeBinary
2915
+ );
2916
+
2917
+
2918
+ /**
2919
+ * @param {!proto.sniipbillapi.LockBillRequest} request The
2920
+ * request proto
2921
+ * @param {?Object<string, string>} metadata User defined
2922
+ * call metadata
2923
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
2924
+ * callback The callback function(error, response)
2925
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
2926
+ * The XHR Node Readable Stream
2927
+ */
2928
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.lockBill =
2929
+ function(request, metadata, callback) {
2930
+ return this.client_.rpcCall(this.hostname_ +
2931
+ '/sniipbillapi.SniipBillAPIService/LockBill',
2932
+ request,
2933
+ metadata || {},
2934
+ methodDescriptor_SniipBillAPIService_LockBill,
2935
+ callback);
2936
+ };
2937
+
2938
+
2939
+ /**
2940
+ * @param {!proto.sniipbillapi.LockBillRequest} request The
2941
+ * request proto
2942
+ * @param {?Object<string, string>} metadata User defined
2943
+ * call metadata
2944
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
2945
+ * Promise that resolves to the response
2946
+ */
2947
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.lockBill =
2948
+ function(request, metadata) {
2949
+ return this.client_.unaryCall(this.hostname_ +
2950
+ '/sniipbillapi.SniipBillAPIService/LockBill',
2951
+ request,
2952
+ metadata || {},
2953
+ methodDescriptor_SniipBillAPIService_LockBill);
2954
+ };
2955
+
2956
+
2957
+ /**
2958
+ * @const
2959
+ * @type {!grpc.web.MethodDescriptor<
2960
+ * !proto.sniipbillapi.LockBillsRequest,
2961
+ * !proto.sniipbillapi.ResponseCode>}
2962
+ */
2963
+ const methodDescriptor_SniipBillAPIService_LockBills = new grpc.web.MethodDescriptor(
2964
+ '/sniipbillapi.SniipBillAPIService/LockBills',
2965
+ grpc.web.MethodType.UNARY,
2966
+ proto.sniipbillapi.LockBillsRequest,
2967
+ proto.sniipbillapi.ResponseCode,
2968
+ /**
2969
+ * @param {!proto.sniipbillapi.LockBillsRequest} request
2970
+ * @return {!Uint8Array}
2971
+ */
2972
+ function(request) {
2973
+ return request.serializeBinary();
2974
+ },
2975
+ proto.sniipbillapi.ResponseCode.deserializeBinary
2976
+ );
2977
+
2978
+
2979
+ /**
2980
+ * @const
2981
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
2982
+ * !proto.sniipbillapi.LockBillsRequest,
2983
+ * !proto.sniipbillapi.ResponseCode>}
2984
+ */
2985
+ const methodInfo_SniipBillAPIService_LockBills = new grpc.web.AbstractClientBase.MethodInfo(
2986
+ proto.sniipbillapi.ResponseCode,
2987
+ /**
2988
+ * @param {!proto.sniipbillapi.LockBillsRequest} request
2989
+ * @return {!Uint8Array}
2990
+ */
2991
+ function(request) {
2992
+ return request.serializeBinary();
2993
+ },
2994
+ proto.sniipbillapi.ResponseCode.deserializeBinary
2995
+ );
2996
+
2997
+
2998
+ /**
2999
+ * @param {!proto.sniipbillapi.LockBillsRequest} request The
3000
+ * request proto
3001
+ * @param {?Object<string, string>} metadata User defined
3002
+ * call metadata
3003
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
3004
+ * callback The callback function(error, response)
3005
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
3006
+ * The XHR Node Readable Stream
3007
+ */
3008
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.lockBills =
3009
+ function(request, metadata, callback) {
3010
+ return this.client_.rpcCall(this.hostname_ +
3011
+ '/sniipbillapi.SniipBillAPIService/LockBills',
3012
+ request,
3013
+ metadata || {},
3014
+ methodDescriptor_SniipBillAPIService_LockBills,
3015
+ callback);
3016
+ };
3017
+
3018
+
3019
+ /**
3020
+ * @param {!proto.sniipbillapi.LockBillsRequest} request The
3021
+ * request proto
3022
+ * @param {?Object<string, string>} metadata User defined
3023
+ * call metadata
3024
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
3025
+ * Promise that resolves to the response
3026
+ */
3027
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.lockBills =
3028
+ function(request, metadata) {
3029
+ return this.client_.unaryCall(this.hostname_ +
3030
+ '/sniipbillapi.SniipBillAPIService/LockBills',
3031
+ request,
3032
+ metadata || {},
3033
+ methodDescriptor_SniipBillAPIService_LockBills);
3034
+ };
3035
+
3036
+
3037
+ /**
3038
+ * @const
3039
+ * @type {!grpc.web.MethodDescriptor<
3040
+ * !proto.sniipbillapi.MarkBillAsPaidRequest,
3041
+ * !proto.sniipbillapi.ResponseCode>}
3042
+ */
3043
+ const methodDescriptor_SniipBillAPIService_MarkBillAsPaid = new grpc.web.MethodDescriptor(
3044
+ '/sniipbillapi.SniipBillAPIService/MarkBillAsPaid',
3045
+ grpc.web.MethodType.UNARY,
3046
+ proto.sniipbillapi.MarkBillAsPaidRequest,
3047
+ proto.sniipbillapi.ResponseCode,
3048
+ /**
3049
+ * @param {!proto.sniipbillapi.MarkBillAsPaidRequest} request
3050
+ * @return {!Uint8Array}
3051
+ */
3052
+ function(request) {
3053
+ return request.serializeBinary();
3054
+ },
3055
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3056
+ );
3057
+
3058
+
3059
+ /**
3060
+ * @const
3061
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3062
+ * !proto.sniipbillapi.MarkBillAsPaidRequest,
3063
+ * !proto.sniipbillapi.ResponseCode>}
3064
+ */
3065
+ const methodInfo_SniipBillAPIService_MarkBillAsPaid = new grpc.web.AbstractClientBase.MethodInfo(
3066
+ proto.sniipbillapi.ResponseCode,
3067
+ /**
3068
+ * @param {!proto.sniipbillapi.MarkBillAsPaidRequest} request
3069
+ * @return {!Uint8Array}
3070
+ */
3071
+ function(request) {
3072
+ return request.serializeBinary();
3073
+ },
3074
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3075
+ );
3076
+
3077
+
3078
+ /**
3079
+ * @param {!proto.sniipbillapi.MarkBillAsPaidRequest} request The
3080
+ * request proto
3081
+ * @param {?Object<string, string>} metadata User defined
3082
+ * call metadata
3083
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
3084
+ * callback The callback function(error, response)
3085
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
3086
+ * The XHR Node Readable Stream
3087
+ */
3088
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.markBillAsPaid =
3089
+ function(request, metadata, callback) {
3090
+ return this.client_.rpcCall(this.hostname_ +
3091
+ '/sniipbillapi.SniipBillAPIService/MarkBillAsPaid',
3092
+ request,
3093
+ metadata || {},
3094
+ methodDescriptor_SniipBillAPIService_MarkBillAsPaid,
3095
+ callback);
3096
+ };
3097
+
3098
+
3099
+ /**
3100
+ * @param {!proto.sniipbillapi.MarkBillAsPaidRequest} request The
3101
+ * request proto
3102
+ * @param {?Object<string, string>} metadata User defined
3103
+ * call metadata
3104
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
3105
+ * Promise that resolves to the response
3106
+ */
3107
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.markBillAsPaid =
3108
+ function(request, metadata) {
3109
+ return this.client_.unaryCall(this.hostname_ +
3110
+ '/sniipbillapi.SniipBillAPIService/MarkBillAsPaid',
3111
+ request,
3112
+ metadata || {},
3113
+ methodDescriptor_SniipBillAPIService_MarkBillAsPaid);
3114
+ };
3115
+
3116
+
3117
+ /**
3118
+ * @const
3119
+ * @type {!grpc.web.MethodDescriptor<
3120
+ * !proto.sniipbillapi.MarkBillAsUnpaidRequest,
3121
+ * !proto.sniipbillapi.ResponseCode>}
3122
+ */
3123
+ const methodDescriptor_SniipBillAPIService_MarkBillAsUnpaid = new grpc.web.MethodDescriptor(
3124
+ '/sniipbillapi.SniipBillAPIService/MarkBillAsUnpaid',
3125
+ grpc.web.MethodType.UNARY,
3126
+ proto.sniipbillapi.MarkBillAsUnpaidRequest,
3127
+ proto.sniipbillapi.ResponseCode,
3128
+ /**
3129
+ * @param {!proto.sniipbillapi.MarkBillAsUnpaidRequest} request
3130
+ * @return {!Uint8Array}
3131
+ */
3132
+ function(request) {
3133
+ return request.serializeBinary();
3134
+ },
3135
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3136
+ );
3137
+
3138
+
3139
+ /**
3140
+ * @const
3141
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3142
+ * !proto.sniipbillapi.MarkBillAsUnpaidRequest,
3143
+ * !proto.sniipbillapi.ResponseCode>}
3144
+ */
3145
+ const methodInfo_SniipBillAPIService_MarkBillAsUnpaid = new grpc.web.AbstractClientBase.MethodInfo(
3146
+ proto.sniipbillapi.ResponseCode,
3147
+ /**
3148
+ * @param {!proto.sniipbillapi.MarkBillAsUnpaidRequest} request
3149
+ * @return {!Uint8Array}
3150
+ */
3151
+ function(request) {
3152
+ return request.serializeBinary();
3153
+ },
3154
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3155
+ );
3156
+
3157
+
3158
+ /**
3159
+ * @param {!proto.sniipbillapi.MarkBillAsUnpaidRequest} request The
3160
+ * request proto
3161
+ * @param {?Object<string, string>} metadata User defined
3162
+ * call metadata
3163
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
3164
+ * callback The callback function(error, response)
3165
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
3166
+ * The XHR Node Readable Stream
3167
+ */
3168
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.markBillAsUnpaid =
3169
+ function(request, metadata, callback) {
3170
+ return this.client_.rpcCall(this.hostname_ +
3171
+ '/sniipbillapi.SniipBillAPIService/MarkBillAsUnpaid',
3172
+ request,
3173
+ metadata || {},
3174
+ methodDescriptor_SniipBillAPIService_MarkBillAsUnpaid,
3175
+ callback);
3176
+ };
3177
+
3178
+
3179
+ /**
3180
+ * @param {!proto.sniipbillapi.MarkBillAsUnpaidRequest} request The
3181
+ * request proto
3182
+ * @param {?Object<string, string>} metadata User defined
3183
+ * call metadata
3184
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
3185
+ * Promise that resolves to the response
3186
+ */
3187
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.markBillAsUnpaid =
3188
+ function(request, metadata) {
3189
+ return this.client_.unaryCall(this.hostname_ +
3190
+ '/sniipbillapi.SniipBillAPIService/MarkBillAsUnpaid',
3191
+ request,
3192
+ metadata || {},
3193
+ methodDescriptor_SniipBillAPIService_MarkBillAsUnpaid);
3194
+ };
3195
+
3196
+
3197
+ /**
3198
+ * @const
3199
+ * @type {!grpc.web.MethodDescriptor<
3200
+ * !proto.google.protobuf.Empty,
3201
+ * !proto.sniipbillapi.ResponseCode>}
3202
+ */
3203
+ const methodDescriptor_SniipBillAPIService_MarkOverdueBills = new grpc.web.MethodDescriptor(
3204
+ '/sniipbillapi.SniipBillAPIService/MarkOverdueBills',
3205
+ grpc.web.MethodType.UNARY,
3206
+ google_protobuf_empty_pb.Empty,
3207
+ proto.sniipbillapi.ResponseCode,
3208
+ /**
3209
+ * @param {!proto.google.protobuf.Empty} request
3210
+ * @return {!Uint8Array}
3211
+ */
3212
+ function(request) {
3213
+ return request.serializeBinary();
3214
+ },
3215
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3216
+ );
3217
+
3218
+
3219
+ /**
3220
+ * @const
3221
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3222
+ * !proto.google.protobuf.Empty,
3223
+ * !proto.sniipbillapi.ResponseCode>}
3224
+ */
3225
+ const methodInfo_SniipBillAPIService_MarkOverdueBills = new grpc.web.AbstractClientBase.MethodInfo(
3226
+ proto.sniipbillapi.ResponseCode,
3227
+ /**
3228
+ * @param {!proto.google.protobuf.Empty} request
3229
+ * @return {!Uint8Array}
3230
+ */
3231
+ function(request) {
3232
+ return request.serializeBinary();
3233
+ },
3234
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3235
+ );
3236
+
3237
+
3238
+ /**
3239
+ * @param {!proto.google.protobuf.Empty} request The
3240
+ * request proto
3241
+ * @param {?Object<string, string>} metadata User defined
3242
+ * call metadata
3243
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
3244
+ * callback The callback function(error, response)
3245
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
3246
+ * The XHR Node Readable Stream
3247
+ */
3248
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.markOverdueBills =
3249
+ function(request, metadata, callback) {
3250
+ return this.client_.rpcCall(this.hostname_ +
3251
+ '/sniipbillapi.SniipBillAPIService/MarkOverdueBills',
3252
+ request,
3253
+ metadata || {},
3254
+ methodDescriptor_SniipBillAPIService_MarkOverdueBills,
3255
+ callback);
3256
+ };
3257
+
3258
+
3259
+ /**
3260
+ * @param {!proto.google.protobuf.Empty} request The
3261
+ * request proto
3262
+ * @param {?Object<string, string>} metadata User defined
3263
+ * call metadata
3264
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
3265
+ * Promise that resolves to the response
3266
+ */
3267
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.markOverdueBills =
3268
+ function(request, metadata) {
3269
+ return this.client_.unaryCall(this.hostname_ +
3270
+ '/sniipbillapi.SniipBillAPIService/MarkOverdueBills',
3271
+ request,
3272
+ metadata || {},
3273
+ methodDescriptor_SniipBillAPIService_MarkOverdueBills);
3274
+ };
3275
+
3276
+
3277
+ /**
3278
+ * @const
3279
+ * @type {!grpc.web.MethodDescriptor<
3280
+ * !proto.google.protobuf.Empty,
3281
+ * !proto.sniipbillapi.ResponseCode>}
3282
+ */
3283
+ const methodDescriptor_SniipBillAPIService_ReconciliateBillBalance = new grpc.web.MethodDescriptor(
3284
+ '/sniipbillapi.SniipBillAPIService/ReconciliateBillBalance',
3285
+ grpc.web.MethodType.UNARY,
3286
+ google_protobuf_empty_pb.Empty,
3287
+ proto.sniipbillapi.ResponseCode,
3288
+ /**
3289
+ * @param {!proto.google.protobuf.Empty} request
3290
+ * @return {!Uint8Array}
3291
+ */
3292
+ function(request) {
3293
+ return request.serializeBinary();
3294
+ },
3295
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3296
+ );
3297
+
3298
+
3299
+ /**
3300
+ * @const
3301
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3302
+ * !proto.google.protobuf.Empty,
3303
+ * !proto.sniipbillapi.ResponseCode>}
3304
+ */
3305
+ const methodInfo_SniipBillAPIService_ReconciliateBillBalance = new grpc.web.AbstractClientBase.MethodInfo(
3306
+ proto.sniipbillapi.ResponseCode,
3307
+ /**
3308
+ * @param {!proto.google.protobuf.Empty} request
3309
+ * @return {!Uint8Array}
3310
+ */
3311
+ function(request) {
3312
+ return request.serializeBinary();
3313
+ },
3314
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3315
+ );
3316
+
3317
+
3318
+ /**
3319
+ * @param {!proto.google.protobuf.Empty} request The
3320
+ * request proto
3321
+ * @param {?Object<string, string>} metadata User defined
3322
+ * call metadata
3323
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
3324
+ * callback The callback function(error, response)
3325
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
3326
+ * The XHR Node Readable Stream
3327
+ */
3328
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.reconciliateBillBalance =
3329
+ function(request, metadata, callback) {
3330
+ return this.client_.rpcCall(this.hostname_ +
3331
+ '/sniipbillapi.SniipBillAPIService/ReconciliateBillBalance',
3332
+ request,
3333
+ metadata || {},
3334
+ methodDescriptor_SniipBillAPIService_ReconciliateBillBalance,
3335
+ callback);
3336
+ };
3337
+
3338
+
3339
+ /**
3340
+ * @param {!proto.google.protobuf.Empty} request The
3341
+ * request proto
3342
+ * @param {?Object<string, string>} metadata User defined
3343
+ * call metadata
3344
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
3345
+ * Promise that resolves to the response
3346
+ */
3347
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.reconciliateBillBalance =
3348
+ function(request, metadata) {
3349
+ return this.client_.unaryCall(this.hostname_ +
3350
+ '/sniipbillapi.SniipBillAPIService/ReconciliateBillBalance',
3351
+ request,
3352
+ metadata || {},
3353
+ methodDescriptor_SniipBillAPIService_ReconciliateBillBalance);
3354
+ };
3355
+
3356
+
3357
+ /**
3358
+ * @const
3359
+ * @type {!grpc.web.MethodDescriptor<
3360
+ * !proto.sniipbillapi.RetrieveBillDetailsRequest,
3361
+ * !proto.sniipbillapi.BillDetailsResponse>}
3362
+ */
3363
+ const methodDescriptor_SniipBillAPIService_RetrieveBillDetails = new grpc.web.MethodDescriptor(
3364
+ '/sniipbillapi.SniipBillAPIService/RetrieveBillDetails',
3365
+ grpc.web.MethodType.UNARY,
3366
+ proto.sniipbillapi.RetrieveBillDetailsRequest,
3367
+ proto.sniipbillapi.BillDetailsResponse,
3368
+ /**
3369
+ * @param {!proto.sniipbillapi.RetrieveBillDetailsRequest} request
3370
+ * @return {!Uint8Array}
3371
+ */
3372
+ function(request) {
3373
+ return request.serializeBinary();
3374
+ },
3375
+ proto.sniipbillapi.BillDetailsResponse.deserializeBinary
3376
+ );
3377
+
3378
+
3379
+ /**
3380
+ * @const
3381
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3382
+ * !proto.sniipbillapi.RetrieveBillDetailsRequest,
3383
+ * !proto.sniipbillapi.BillDetailsResponse>}
3384
+ */
3385
+ const methodInfo_SniipBillAPIService_RetrieveBillDetails = new grpc.web.AbstractClientBase.MethodInfo(
3386
+ proto.sniipbillapi.BillDetailsResponse,
3387
+ /**
3388
+ * @param {!proto.sniipbillapi.RetrieveBillDetailsRequest} request
3389
+ * @return {!Uint8Array}
3390
+ */
3391
+ function(request) {
3392
+ return request.serializeBinary();
3393
+ },
3394
+ proto.sniipbillapi.BillDetailsResponse.deserializeBinary
3395
+ );
3396
+
3397
+
3398
+ /**
3399
+ * @param {!proto.sniipbillapi.RetrieveBillDetailsRequest} request The
3400
+ * request proto
3401
+ * @param {?Object<string, string>} metadata User defined
3402
+ * call metadata
3403
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillDetailsResponse)}
3404
+ * callback The callback function(error, response)
3405
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillDetailsResponse>|undefined}
3406
+ * The XHR Node Readable Stream
3407
+ */
3408
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.retrieveBillDetails =
3409
+ function(request, metadata, callback) {
3410
+ return this.client_.rpcCall(this.hostname_ +
3411
+ '/sniipbillapi.SniipBillAPIService/RetrieveBillDetails',
3412
+ request,
3413
+ metadata || {},
3414
+ methodDescriptor_SniipBillAPIService_RetrieveBillDetails,
3415
+ callback);
3416
+ };
3417
+
3418
+
3419
+ /**
3420
+ * @param {!proto.sniipbillapi.RetrieveBillDetailsRequest} request The
3421
+ * request proto
3422
+ * @param {?Object<string, string>} metadata User defined
3423
+ * call metadata
3424
+ * @return {!Promise<!proto.sniipbillapi.BillDetailsResponse>}
3425
+ * Promise that resolves to the response
3426
+ */
3427
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.retrieveBillDetails =
3428
+ function(request, metadata) {
3429
+ return this.client_.unaryCall(this.hostname_ +
3430
+ '/sniipbillapi.SniipBillAPIService/RetrieveBillDetails',
3431
+ request,
3432
+ metadata || {},
3433
+ methodDescriptor_SniipBillAPIService_RetrieveBillDetails);
3434
+ };
3435
+
3436
+
3437
+ /**
3438
+ * @const
3439
+ * @type {!grpc.web.MethodDescriptor<
3440
+ * !proto.sniipbillapi.SaveItemPaymentDetailsRequest,
3441
+ * !proto.sniipbillapi.CreateItemPaymentResponse>}
3442
+ */
3443
+ const methodDescriptor_SniipBillAPIService_SaveItemPaymentDetails = new grpc.web.MethodDescriptor(
3444
+ '/sniipbillapi.SniipBillAPIService/SaveItemPaymentDetails',
3445
+ grpc.web.MethodType.UNARY,
3446
+ proto.sniipbillapi.SaveItemPaymentDetailsRequest,
3447
+ proto.sniipbillapi.CreateItemPaymentResponse,
3448
+ /**
3449
+ * @param {!proto.sniipbillapi.SaveItemPaymentDetailsRequest} request
3450
+ * @return {!Uint8Array}
3451
+ */
3452
+ function(request) {
3453
+ return request.serializeBinary();
3454
+ },
3455
+ proto.sniipbillapi.CreateItemPaymentResponse.deserializeBinary
3456
+ );
3457
+
3458
+
3459
+ /**
3460
+ * @const
3461
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3462
+ * !proto.sniipbillapi.SaveItemPaymentDetailsRequest,
3463
+ * !proto.sniipbillapi.CreateItemPaymentResponse>}
3464
+ */
3465
+ const methodInfo_SniipBillAPIService_SaveItemPaymentDetails = new grpc.web.AbstractClientBase.MethodInfo(
3466
+ proto.sniipbillapi.CreateItemPaymentResponse,
3467
+ /**
3468
+ * @param {!proto.sniipbillapi.SaveItemPaymentDetailsRequest} request
3469
+ * @return {!Uint8Array}
3470
+ */
3471
+ function(request) {
3472
+ return request.serializeBinary();
3473
+ },
3474
+ proto.sniipbillapi.CreateItemPaymentResponse.deserializeBinary
3475
+ );
3476
+
3477
+
3478
+ /**
3479
+ * @param {!proto.sniipbillapi.SaveItemPaymentDetailsRequest} request The
3480
+ * request proto
3481
+ * @param {?Object<string, string>} metadata User defined
3482
+ * call metadata
3483
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.CreateItemPaymentResponse)}
3484
+ * callback The callback function(error, response)
3485
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.CreateItemPaymentResponse>|undefined}
3486
+ * The XHR Node Readable Stream
3487
+ */
3488
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.saveItemPaymentDetails =
3489
+ function(request, metadata, callback) {
3490
+ return this.client_.rpcCall(this.hostname_ +
3491
+ '/sniipbillapi.SniipBillAPIService/SaveItemPaymentDetails',
3492
+ request,
3493
+ metadata || {},
3494
+ methodDescriptor_SniipBillAPIService_SaveItemPaymentDetails,
3495
+ callback);
3496
+ };
3497
+
3498
+
3499
+ /**
3500
+ * @param {!proto.sniipbillapi.SaveItemPaymentDetailsRequest} request The
3501
+ * request proto
3502
+ * @param {?Object<string, string>} metadata User defined
3503
+ * call metadata
3504
+ * @return {!Promise<!proto.sniipbillapi.CreateItemPaymentResponse>}
3505
+ * Promise that resolves to the response
3506
+ */
3507
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.saveItemPaymentDetails =
3508
+ function(request, metadata) {
3509
+ return this.client_.unaryCall(this.hostname_ +
3510
+ '/sniipbillapi.SniipBillAPIService/SaveItemPaymentDetails',
3511
+ request,
3512
+ metadata || {},
3513
+ methodDescriptor_SniipBillAPIService_SaveItemPaymentDetails);
3514
+ };
3515
+
3516
+
3517
+ /**
3518
+ * @const
3519
+ * @type {!grpc.web.MethodDescriptor<
3520
+ * !proto.sniipbillapi.SearchBillersRequest,
3521
+ * !proto.sniipbillapi.SearchBillerResponse>}
3522
+ */
3523
+ const methodDescriptor_SniipBillAPIService_SearchBillers = new grpc.web.MethodDescriptor(
3524
+ '/sniipbillapi.SniipBillAPIService/SearchBillers',
3525
+ grpc.web.MethodType.UNARY,
3526
+ proto.sniipbillapi.SearchBillersRequest,
3527
+ proto.sniipbillapi.SearchBillerResponse,
3528
+ /**
3529
+ * @param {!proto.sniipbillapi.SearchBillersRequest} request
3530
+ * @return {!Uint8Array}
3531
+ */
3532
+ function(request) {
3533
+ return request.serializeBinary();
3534
+ },
3535
+ proto.sniipbillapi.SearchBillerResponse.deserializeBinary
3536
+ );
3537
+
3538
+
3539
+ /**
3540
+ * @const
3541
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3542
+ * !proto.sniipbillapi.SearchBillersRequest,
3543
+ * !proto.sniipbillapi.SearchBillerResponse>}
3544
+ */
3545
+ const methodInfo_SniipBillAPIService_SearchBillers = new grpc.web.AbstractClientBase.MethodInfo(
3546
+ proto.sniipbillapi.SearchBillerResponse,
3547
+ /**
3548
+ * @param {!proto.sniipbillapi.SearchBillersRequest} request
3549
+ * @return {!Uint8Array}
3550
+ */
3551
+ function(request) {
3552
+ return request.serializeBinary();
3553
+ },
3554
+ proto.sniipbillapi.SearchBillerResponse.deserializeBinary
3555
+ );
3556
+
3557
+
3558
+ /**
3559
+ * @param {!proto.sniipbillapi.SearchBillersRequest} request The
3560
+ * request proto
3561
+ * @param {?Object<string, string>} metadata User defined
3562
+ * call metadata
3563
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.SearchBillerResponse)}
3564
+ * callback The callback function(error, response)
3565
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.SearchBillerResponse>|undefined}
3566
+ * The XHR Node Readable Stream
3567
+ */
3568
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.searchBillers =
3569
+ function(request, metadata, callback) {
3570
+ return this.client_.rpcCall(this.hostname_ +
3571
+ '/sniipbillapi.SniipBillAPIService/SearchBillers',
3572
+ request,
3573
+ metadata || {},
3574
+ methodDescriptor_SniipBillAPIService_SearchBillers,
3575
+ callback);
3576
+ };
3577
+
3578
+
3579
+ /**
3580
+ * @param {!proto.sniipbillapi.SearchBillersRequest} request The
3581
+ * request proto
3582
+ * @param {?Object<string, string>} metadata User defined
3583
+ * call metadata
3584
+ * @return {!Promise<!proto.sniipbillapi.SearchBillerResponse>}
3585
+ * Promise that resolves to the response
3586
+ */
3587
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.searchBillers =
3588
+ function(request, metadata) {
3589
+ return this.client_.unaryCall(this.hostname_ +
3590
+ '/sniipbillapi.SniipBillAPIService/SearchBillers',
3591
+ request,
3592
+ metadata || {},
3593
+ methodDescriptor_SniipBillAPIService_SearchBillers);
3594
+ };
3595
+
3596
+
3597
+ /**
3598
+ * @const
3599
+ * @type {!grpc.web.MethodDescriptor<
3600
+ * !proto.sniipbillapi.SendBillDueSoonNotificationRequest,
3601
+ * !proto.sniipbillapi.ResponseCode>}
3602
+ */
3603
+ const methodDescriptor_SniipBillAPIService_SendBillDueSoonNotification = new grpc.web.MethodDescriptor(
3604
+ '/sniipbillapi.SniipBillAPIService/SendBillDueSoonNotification',
3605
+ grpc.web.MethodType.UNARY,
3606
+ proto.sniipbillapi.SendBillDueSoonNotificationRequest,
3607
+ proto.sniipbillapi.ResponseCode,
3608
+ /**
3609
+ * @param {!proto.sniipbillapi.SendBillDueSoonNotificationRequest} request
3610
+ * @return {!Uint8Array}
3611
+ */
3612
+ function(request) {
3613
+ return request.serializeBinary();
3614
+ },
3615
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3616
+ );
3617
+
3618
+
3619
+ /**
3620
+ * @const
3621
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3622
+ * !proto.sniipbillapi.SendBillDueSoonNotificationRequest,
3623
+ * !proto.sniipbillapi.ResponseCode>}
3624
+ */
3625
+ const methodInfo_SniipBillAPIService_SendBillDueSoonNotification = new grpc.web.AbstractClientBase.MethodInfo(
3626
+ proto.sniipbillapi.ResponseCode,
3627
+ /**
3628
+ * @param {!proto.sniipbillapi.SendBillDueSoonNotificationRequest} request
3629
+ * @return {!Uint8Array}
3630
+ */
3631
+ function(request) {
3632
+ return request.serializeBinary();
3633
+ },
3634
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3635
+ );
3636
+
3637
+
3638
+ /**
3639
+ * @param {!proto.sniipbillapi.SendBillDueSoonNotificationRequest} request The
3640
+ * request proto
3641
+ * @param {?Object<string, string>} metadata User defined
3642
+ * call metadata
3643
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
3644
+ * callback The callback function(error, response)
3645
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
3646
+ * The XHR Node Readable Stream
3647
+ */
3648
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.sendBillDueSoonNotification =
3649
+ function(request, metadata, callback) {
3650
+ return this.client_.rpcCall(this.hostname_ +
3651
+ '/sniipbillapi.SniipBillAPIService/SendBillDueSoonNotification',
3652
+ request,
3653
+ metadata || {},
3654
+ methodDescriptor_SniipBillAPIService_SendBillDueSoonNotification,
3655
+ callback);
3656
+ };
3657
+
3658
+
3659
+ /**
3660
+ * @param {!proto.sniipbillapi.SendBillDueSoonNotificationRequest} request The
3661
+ * request proto
3662
+ * @param {?Object<string, string>} metadata User defined
3663
+ * call metadata
3664
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
3665
+ * Promise that resolves to the response
3666
+ */
3667
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.sendBillDueSoonNotification =
3668
+ function(request, metadata) {
3669
+ return this.client_.unaryCall(this.hostname_ +
3670
+ '/sniipbillapi.SniipBillAPIService/SendBillDueSoonNotification',
3671
+ request,
3672
+ metadata || {},
3673
+ methodDescriptor_SniipBillAPIService_SendBillDueSoonNotification);
3674
+ };
3675
+
3676
+
3677
+ /**
3678
+ * @const
3679
+ * @type {!grpc.web.MethodDescriptor<
3680
+ * !proto.sniipbillapi.SetBillRequiresAttentionRequest,
3681
+ * !proto.sniipbillapi.ResponseCode>}
3682
+ */
3683
+ const methodDescriptor_SniipBillAPIService_SetBillRequiresAttention = new grpc.web.MethodDescriptor(
3684
+ '/sniipbillapi.SniipBillAPIService/SetBillRequiresAttention',
3685
+ grpc.web.MethodType.UNARY,
3686
+ proto.sniipbillapi.SetBillRequiresAttentionRequest,
3687
+ proto.sniipbillapi.ResponseCode,
3688
+ /**
3689
+ * @param {!proto.sniipbillapi.SetBillRequiresAttentionRequest} request
3690
+ * @return {!Uint8Array}
3691
+ */
3692
+ function(request) {
3693
+ return request.serializeBinary();
3694
+ },
3695
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3696
+ );
3697
+
3698
+
3699
+ /**
3700
+ * @const
3701
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3702
+ * !proto.sniipbillapi.SetBillRequiresAttentionRequest,
3703
+ * !proto.sniipbillapi.ResponseCode>}
3704
+ */
3705
+ const methodInfo_SniipBillAPIService_SetBillRequiresAttention = new grpc.web.AbstractClientBase.MethodInfo(
3706
+ proto.sniipbillapi.ResponseCode,
3707
+ /**
3708
+ * @param {!proto.sniipbillapi.SetBillRequiresAttentionRequest} request
3709
+ * @return {!Uint8Array}
3710
+ */
3711
+ function(request) {
3712
+ return request.serializeBinary();
3713
+ },
3714
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3715
+ );
3716
+
3717
+
3718
+ /**
3719
+ * @param {!proto.sniipbillapi.SetBillRequiresAttentionRequest} request The
3720
+ * request proto
3721
+ * @param {?Object<string, string>} metadata User defined
3722
+ * call metadata
3723
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
3724
+ * callback The callback function(error, response)
3725
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
3726
+ * The XHR Node Readable Stream
3727
+ */
3728
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.setBillRequiresAttention =
3729
+ function(request, metadata, callback) {
3730
+ return this.client_.rpcCall(this.hostname_ +
3731
+ '/sniipbillapi.SniipBillAPIService/SetBillRequiresAttention',
3732
+ request,
3733
+ metadata || {},
3734
+ methodDescriptor_SniipBillAPIService_SetBillRequiresAttention,
3735
+ callback);
3736
+ };
3737
+
3738
+
3739
+ /**
3740
+ * @param {!proto.sniipbillapi.SetBillRequiresAttentionRequest} request The
3741
+ * request proto
3742
+ * @param {?Object<string, string>} metadata User defined
3743
+ * call metadata
3744
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
3745
+ * Promise that resolves to the response
3746
+ */
3747
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.setBillRequiresAttention =
3748
+ function(request, metadata) {
3749
+ return this.client_.unaryCall(this.hostname_ +
3750
+ '/sniipbillapi.SniipBillAPIService/SetBillRequiresAttention',
3751
+ request,
3752
+ metadata || {},
3753
+ methodDescriptor_SniipBillAPIService_SetBillRequiresAttention);
3754
+ };
3755
+
3756
+
3757
+ /**
3758
+ * @const
3759
+ * @type {!grpc.web.MethodDescriptor<
3760
+ * !proto.sniipbillapi.SetBillerCrnNicknameRequest,
3761
+ * !proto.sniipbillapi.ResponseCode>}
3762
+ */
3763
+ const methodDescriptor_SniipBillAPIService_SetBillerCrnNickname = new grpc.web.MethodDescriptor(
3764
+ '/sniipbillapi.SniipBillAPIService/SetBillerCrnNickname',
3765
+ grpc.web.MethodType.UNARY,
3766
+ proto.sniipbillapi.SetBillerCrnNicknameRequest,
3767
+ proto.sniipbillapi.ResponseCode,
3768
+ /**
3769
+ * @param {!proto.sniipbillapi.SetBillerCrnNicknameRequest} request
3770
+ * @return {!Uint8Array}
3771
+ */
3772
+ function(request) {
3773
+ return request.serializeBinary();
3774
+ },
3775
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3776
+ );
3777
+
3778
+
3779
+ /**
3780
+ * @const
3781
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3782
+ * !proto.sniipbillapi.SetBillerCrnNicknameRequest,
3783
+ * !proto.sniipbillapi.ResponseCode>}
3784
+ */
3785
+ const methodInfo_SniipBillAPIService_SetBillerCrnNickname = new grpc.web.AbstractClientBase.MethodInfo(
3786
+ proto.sniipbillapi.ResponseCode,
3787
+ /**
3788
+ * @param {!proto.sniipbillapi.SetBillerCrnNicknameRequest} request
3789
+ * @return {!Uint8Array}
3790
+ */
3791
+ function(request) {
3792
+ return request.serializeBinary();
3793
+ },
3794
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3795
+ );
3796
+
3797
+
3798
+ /**
3799
+ * @param {!proto.sniipbillapi.SetBillerCrnNicknameRequest} request The
3800
+ * request proto
3801
+ * @param {?Object<string, string>} metadata User defined
3802
+ * call metadata
3803
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
3804
+ * callback The callback function(error, response)
3805
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
3806
+ * The XHR Node Readable Stream
3807
+ */
3808
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.setBillerCrnNickname =
3809
+ function(request, metadata, callback) {
3810
+ return this.client_.rpcCall(this.hostname_ +
3811
+ '/sniipbillapi.SniipBillAPIService/SetBillerCrnNickname',
3812
+ request,
3813
+ metadata || {},
3814
+ methodDescriptor_SniipBillAPIService_SetBillerCrnNickname,
3815
+ callback);
3816
+ };
3817
+
3818
+
3819
+ /**
3820
+ * @param {!proto.sniipbillapi.SetBillerCrnNicknameRequest} request The
3821
+ * request proto
3822
+ * @param {?Object<string, string>} metadata User defined
3823
+ * call metadata
3824
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
3825
+ * Promise that resolves to the response
3826
+ */
3827
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.setBillerCrnNickname =
3828
+ function(request, metadata) {
3829
+ return this.client_.unaryCall(this.hostname_ +
3830
+ '/sniipbillapi.SniipBillAPIService/SetBillerCrnNickname',
3831
+ request,
3832
+ metadata || {},
3833
+ methodDescriptor_SniipBillAPIService_SetBillerCrnNickname);
3834
+ };
3835
+
3836
+
3837
+ /**
3838
+ * @const
3839
+ * @type {!grpc.web.MethodDescriptor<
3840
+ * !proto.sniipbillapi.ShareBillEmailRequest,
3841
+ * !proto.sniipbillapi.ResponseCode>}
3842
+ */
3843
+ const methodDescriptor_SniipBillAPIService_ShareBillEmail = new grpc.web.MethodDescriptor(
3844
+ '/sniipbillapi.SniipBillAPIService/ShareBillEmail',
3845
+ grpc.web.MethodType.UNARY,
3846
+ proto.sniipbillapi.ShareBillEmailRequest,
3847
+ proto.sniipbillapi.ResponseCode,
3848
+ /**
3849
+ * @param {!proto.sniipbillapi.ShareBillEmailRequest} request
3850
+ * @return {!Uint8Array}
3851
+ */
3852
+ function(request) {
3853
+ return request.serializeBinary();
3854
+ },
3855
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3856
+ );
3857
+
3858
+
3859
+ /**
3860
+ * @const
3861
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3862
+ * !proto.sniipbillapi.ShareBillEmailRequest,
3863
+ * !proto.sniipbillapi.ResponseCode>}
3864
+ */
3865
+ const methodInfo_SniipBillAPIService_ShareBillEmail = new grpc.web.AbstractClientBase.MethodInfo(
3866
+ proto.sniipbillapi.ResponseCode,
3867
+ /**
3868
+ * @param {!proto.sniipbillapi.ShareBillEmailRequest} request
3869
+ * @return {!Uint8Array}
3870
+ */
3871
+ function(request) {
3872
+ return request.serializeBinary();
3873
+ },
3874
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3875
+ );
3876
+
3877
+
3878
+ /**
3879
+ * @param {!proto.sniipbillapi.ShareBillEmailRequest} request The
3880
+ * request proto
3881
+ * @param {?Object<string, string>} metadata User defined
3882
+ * call metadata
3883
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
3884
+ * callback The callback function(error, response)
3885
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
3886
+ * The XHR Node Readable Stream
3887
+ */
3888
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.shareBillEmail =
3889
+ function(request, metadata, callback) {
3890
+ return this.client_.rpcCall(this.hostname_ +
3891
+ '/sniipbillapi.SniipBillAPIService/ShareBillEmail',
3892
+ request,
3893
+ metadata || {},
3894
+ methodDescriptor_SniipBillAPIService_ShareBillEmail,
3895
+ callback);
3896
+ };
3897
+
3898
+
3899
+ /**
3900
+ * @param {!proto.sniipbillapi.ShareBillEmailRequest} request The
3901
+ * request proto
3902
+ * @param {?Object<string, string>} metadata User defined
3903
+ * call metadata
3904
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
3905
+ * Promise that resolves to the response
3906
+ */
3907
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.shareBillEmail =
3908
+ function(request, metadata) {
3909
+ return this.client_.unaryCall(this.hostname_ +
3910
+ '/sniipbillapi.SniipBillAPIService/ShareBillEmail',
3911
+ request,
3912
+ metadata || {},
3913
+ methodDescriptor_SniipBillAPIService_ShareBillEmail);
3914
+ };
3915
+
3916
+
3917
+ /**
3918
+ * @const
3919
+ * @type {!grpc.web.MethodDescriptor<
3920
+ * !proto.sniipbillapi.UnlockBillRequest,
3921
+ * !proto.sniipbillapi.ResponseCode>}
3922
+ */
3923
+ const methodDescriptor_SniipBillAPIService_UnlockBill = new grpc.web.MethodDescriptor(
3924
+ '/sniipbillapi.SniipBillAPIService/UnlockBill',
3925
+ grpc.web.MethodType.UNARY,
3926
+ proto.sniipbillapi.UnlockBillRequest,
3927
+ proto.sniipbillapi.ResponseCode,
3928
+ /**
3929
+ * @param {!proto.sniipbillapi.UnlockBillRequest} request
3930
+ * @return {!Uint8Array}
3931
+ */
3932
+ function(request) {
3933
+ return request.serializeBinary();
3934
+ },
3935
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3936
+ );
3937
+
3938
+
3939
+ /**
3940
+ * @const
3941
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
3942
+ * !proto.sniipbillapi.UnlockBillRequest,
3943
+ * !proto.sniipbillapi.ResponseCode>}
3944
+ */
3945
+ const methodInfo_SniipBillAPIService_UnlockBill = new grpc.web.AbstractClientBase.MethodInfo(
3946
+ proto.sniipbillapi.ResponseCode,
3947
+ /**
3948
+ * @param {!proto.sniipbillapi.UnlockBillRequest} request
3949
+ * @return {!Uint8Array}
3950
+ */
3951
+ function(request) {
3952
+ return request.serializeBinary();
3953
+ },
3954
+ proto.sniipbillapi.ResponseCode.deserializeBinary
3955
+ );
3956
+
3957
+
3958
+ /**
3959
+ * @param {!proto.sniipbillapi.UnlockBillRequest} request The
3960
+ * request proto
3961
+ * @param {?Object<string, string>} metadata User defined
3962
+ * call metadata
3963
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
3964
+ * callback The callback function(error, response)
3965
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
3966
+ * The XHR Node Readable Stream
3967
+ */
3968
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.unlockBill =
3969
+ function(request, metadata, callback) {
3970
+ return this.client_.rpcCall(this.hostname_ +
3971
+ '/sniipbillapi.SniipBillAPIService/UnlockBill',
3972
+ request,
3973
+ metadata || {},
3974
+ methodDescriptor_SniipBillAPIService_UnlockBill,
3975
+ callback);
3976
+ };
3977
+
3978
+
3979
+ /**
3980
+ * @param {!proto.sniipbillapi.UnlockBillRequest} request The
3981
+ * request proto
3982
+ * @param {?Object<string, string>} metadata User defined
3983
+ * call metadata
3984
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
3985
+ * Promise that resolves to the response
3986
+ */
3987
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.unlockBill =
3988
+ function(request, metadata) {
3989
+ return this.client_.unaryCall(this.hostname_ +
3990
+ '/sniipbillapi.SniipBillAPIService/UnlockBill',
3991
+ request,
3992
+ metadata || {},
3993
+ methodDescriptor_SniipBillAPIService_UnlockBill);
3994
+ };
3995
+
3996
+
3997
+ /**
3998
+ * @const
3999
+ * @type {!grpc.web.MethodDescriptor<
4000
+ * !proto.sniipbillapi.UpdateBillRemindersConfigRequest,
4001
+ * !proto.sniipbillapi.ResponseCode>}
4002
+ */
4003
+ const methodDescriptor_SniipBillAPIService_UpdateBillRemindersConfig = new grpc.web.MethodDescriptor(
4004
+ '/sniipbillapi.SniipBillAPIService/UpdateBillRemindersConfig',
4005
+ grpc.web.MethodType.UNARY,
4006
+ proto.sniipbillapi.UpdateBillRemindersConfigRequest,
4007
+ proto.sniipbillapi.ResponseCode,
4008
+ /**
4009
+ * @param {!proto.sniipbillapi.UpdateBillRemindersConfigRequest} request
4010
+ * @return {!Uint8Array}
4011
+ */
4012
+ function(request) {
4013
+ return request.serializeBinary();
4014
+ },
4015
+ proto.sniipbillapi.ResponseCode.deserializeBinary
4016
+ );
4017
+
4018
+
4019
+ /**
4020
+ * @const
4021
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
4022
+ * !proto.sniipbillapi.UpdateBillRemindersConfigRequest,
4023
+ * !proto.sniipbillapi.ResponseCode>}
4024
+ */
4025
+ const methodInfo_SniipBillAPIService_UpdateBillRemindersConfig = new grpc.web.AbstractClientBase.MethodInfo(
4026
+ proto.sniipbillapi.ResponseCode,
4027
+ /**
4028
+ * @param {!proto.sniipbillapi.UpdateBillRemindersConfigRequest} request
4029
+ * @return {!Uint8Array}
4030
+ */
4031
+ function(request) {
4032
+ return request.serializeBinary();
4033
+ },
4034
+ proto.sniipbillapi.ResponseCode.deserializeBinary
4035
+ );
4036
+
4037
+
4038
+ /**
4039
+ * @param {!proto.sniipbillapi.UpdateBillRemindersConfigRequest} request The
4040
+ * request proto
4041
+ * @param {?Object<string, string>} metadata User defined
4042
+ * call metadata
4043
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
4044
+ * callback The callback function(error, response)
4045
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
4046
+ * The XHR Node Readable Stream
4047
+ */
4048
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.updateBillRemindersConfig =
4049
+ function(request, metadata, callback) {
4050
+ return this.client_.rpcCall(this.hostname_ +
4051
+ '/sniipbillapi.SniipBillAPIService/UpdateBillRemindersConfig',
4052
+ request,
4053
+ metadata || {},
4054
+ methodDescriptor_SniipBillAPIService_UpdateBillRemindersConfig,
4055
+ callback);
4056
+ };
4057
+
4058
+
4059
+ /**
4060
+ * @param {!proto.sniipbillapi.UpdateBillRemindersConfigRequest} request The
4061
+ * request proto
4062
+ * @param {?Object<string, string>} metadata User defined
4063
+ * call metadata
4064
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
4065
+ * Promise that resolves to the response
4066
+ */
4067
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.updateBillRemindersConfig =
4068
+ function(request, metadata) {
4069
+ return this.client_.unaryCall(this.hostname_ +
4070
+ '/sniipbillapi.SniipBillAPIService/UpdateBillRemindersConfig',
4071
+ request,
4072
+ metadata || {},
4073
+ methodDescriptor_SniipBillAPIService_UpdateBillRemindersConfig);
4074
+ };
4075
+
4076
+
4077
+ /**
4078
+ * @const
4079
+ * @type {!grpc.web.MethodDescriptor<
4080
+ * !proto.sniipbillapi.UpdateDueAmountRequest,
4081
+ * !proto.sniipbillapi.UpdateDueAmountResponse>}
4082
+ */
4083
+ const methodDescriptor_SniipBillAPIService_UpdateDueAmount = new grpc.web.MethodDescriptor(
4084
+ '/sniipbillapi.SniipBillAPIService/UpdateDueAmount',
4085
+ grpc.web.MethodType.UNARY,
4086
+ proto.sniipbillapi.UpdateDueAmountRequest,
4087
+ proto.sniipbillapi.UpdateDueAmountResponse,
4088
+ /**
4089
+ * @param {!proto.sniipbillapi.UpdateDueAmountRequest} request
4090
+ * @return {!Uint8Array}
4091
+ */
4092
+ function(request) {
4093
+ return request.serializeBinary();
4094
+ },
4095
+ proto.sniipbillapi.UpdateDueAmountResponse.deserializeBinary
4096
+ );
4097
+
4098
+
4099
+ /**
4100
+ * @const
4101
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
4102
+ * !proto.sniipbillapi.UpdateDueAmountRequest,
4103
+ * !proto.sniipbillapi.UpdateDueAmountResponse>}
4104
+ */
4105
+ const methodInfo_SniipBillAPIService_UpdateDueAmount = new grpc.web.AbstractClientBase.MethodInfo(
4106
+ proto.sniipbillapi.UpdateDueAmountResponse,
4107
+ /**
4108
+ * @param {!proto.sniipbillapi.UpdateDueAmountRequest} request
4109
+ * @return {!Uint8Array}
4110
+ */
4111
+ function(request) {
4112
+ return request.serializeBinary();
4113
+ },
4114
+ proto.sniipbillapi.UpdateDueAmountResponse.deserializeBinary
4115
+ );
4116
+
4117
+
4118
+ /**
4119
+ * @param {!proto.sniipbillapi.UpdateDueAmountRequest} request The
4120
+ * request proto
4121
+ * @param {?Object<string, string>} metadata User defined
4122
+ * call metadata
4123
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.UpdateDueAmountResponse)}
4124
+ * callback The callback function(error, response)
4125
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.UpdateDueAmountResponse>|undefined}
4126
+ * The XHR Node Readable Stream
4127
+ */
4128
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.updateDueAmount =
4129
+ function(request, metadata, callback) {
4130
+ return this.client_.rpcCall(this.hostname_ +
4131
+ '/sniipbillapi.SniipBillAPIService/UpdateDueAmount',
4132
+ request,
4133
+ metadata || {},
4134
+ methodDescriptor_SniipBillAPIService_UpdateDueAmount,
4135
+ callback);
4136
+ };
4137
+
4138
+
4139
+ /**
4140
+ * @param {!proto.sniipbillapi.UpdateDueAmountRequest} request The
4141
+ * request proto
4142
+ * @param {?Object<string, string>} metadata User defined
4143
+ * call metadata
4144
+ * @return {!Promise<!proto.sniipbillapi.UpdateDueAmountResponse>}
4145
+ * Promise that resolves to the response
4146
+ */
4147
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.updateDueAmount =
4148
+ function(request, metadata) {
4149
+ return this.client_.unaryCall(this.hostname_ +
4150
+ '/sniipbillapi.SniipBillAPIService/UpdateDueAmount',
4151
+ request,
4152
+ metadata || {},
4153
+ methodDescriptor_SniipBillAPIService_UpdateDueAmount);
4154
+ };
4155
+
4156
+
4157
+ /**
4158
+ * @const
4159
+ * @type {!grpc.web.MethodDescriptor<
4160
+ * !proto.sniipbillapi.UpdateDueDateRequest,
4161
+ * !proto.sniipbillapi.BillDetailsResponse>}
4162
+ */
4163
+ const methodDescriptor_SniipBillAPIService_UpdateDueDate = new grpc.web.MethodDescriptor(
4164
+ '/sniipbillapi.SniipBillAPIService/UpdateDueDate',
4165
+ grpc.web.MethodType.UNARY,
4166
+ proto.sniipbillapi.UpdateDueDateRequest,
4167
+ proto.sniipbillapi.BillDetailsResponse,
4168
+ /**
4169
+ * @param {!proto.sniipbillapi.UpdateDueDateRequest} request
4170
+ * @return {!Uint8Array}
4171
+ */
4172
+ function(request) {
4173
+ return request.serializeBinary();
4174
+ },
4175
+ proto.sniipbillapi.BillDetailsResponse.deserializeBinary
4176
+ );
4177
+
4178
+
4179
+ /**
4180
+ * @const
4181
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
4182
+ * !proto.sniipbillapi.UpdateDueDateRequest,
4183
+ * !proto.sniipbillapi.BillDetailsResponse>}
4184
+ */
4185
+ const methodInfo_SniipBillAPIService_UpdateDueDate = new grpc.web.AbstractClientBase.MethodInfo(
4186
+ proto.sniipbillapi.BillDetailsResponse,
4187
+ /**
4188
+ * @param {!proto.sniipbillapi.UpdateDueDateRequest} request
4189
+ * @return {!Uint8Array}
4190
+ */
4191
+ function(request) {
4192
+ return request.serializeBinary();
4193
+ },
4194
+ proto.sniipbillapi.BillDetailsResponse.deserializeBinary
4195
+ );
4196
+
4197
+
4198
+ /**
4199
+ * @param {!proto.sniipbillapi.UpdateDueDateRequest} request The
4200
+ * request proto
4201
+ * @param {?Object<string, string>} metadata User defined
4202
+ * call metadata
4203
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.BillDetailsResponse)}
4204
+ * callback The callback function(error, response)
4205
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.BillDetailsResponse>|undefined}
4206
+ * The XHR Node Readable Stream
4207
+ */
4208
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.updateDueDate =
4209
+ function(request, metadata, callback) {
4210
+ return this.client_.rpcCall(this.hostname_ +
4211
+ '/sniipbillapi.SniipBillAPIService/UpdateDueDate',
4212
+ request,
4213
+ metadata || {},
4214
+ methodDescriptor_SniipBillAPIService_UpdateDueDate,
4215
+ callback);
4216
+ };
4217
+
4218
+
4219
+ /**
4220
+ * @param {!proto.sniipbillapi.UpdateDueDateRequest} request The
4221
+ * request proto
4222
+ * @param {?Object<string, string>} metadata User defined
4223
+ * call metadata
4224
+ * @return {!Promise<!proto.sniipbillapi.BillDetailsResponse>}
4225
+ * Promise that resolves to the response
4226
+ */
4227
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.updateDueDate =
4228
+ function(request, metadata) {
4229
+ return this.client_.unaryCall(this.hostname_ +
4230
+ '/sniipbillapi.SniipBillAPIService/UpdateDueDate',
4231
+ request,
4232
+ metadata || {},
4233
+ methodDescriptor_SniipBillAPIService_UpdateDueDate);
4234
+ };
4235
+
4236
+
4237
+ /**
4238
+ * @const
4239
+ * @type {!grpc.web.MethodDescriptor<
4240
+ * !proto.sniipbillapi.UpdateUserBillConfigRequest,
4241
+ * !proto.sniipbillapi.UserBillConfigResponse>}
4242
+ */
4243
+ const methodDescriptor_SniipBillAPIService_UpdateUserBillConfig = new grpc.web.MethodDescriptor(
4244
+ '/sniipbillapi.SniipBillAPIService/UpdateUserBillConfig',
4245
+ grpc.web.MethodType.UNARY,
4246
+ proto.sniipbillapi.UpdateUserBillConfigRequest,
4247
+ proto.sniipbillapi.UserBillConfigResponse,
4248
+ /**
4249
+ * @param {!proto.sniipbillapi.UpdateUserBillConfigRequest} request
4250
+ * @return {!Uint8Array}
4251
+ */
4252
+ function(request) {
4253
+ return request.serializeBinary();
4254
+ },
4255
+ proto.sniipbillapi.UserBillConfigResponse.deserializeBinary
4256
+ );
4257
+
4258
+
4259
+ /**
4260
+ * @const
4261
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
4262
+ * !proto.sniipbillapi.UpdateUserBillConfigRequest,
4263
+ * !proto.sniipbillapi.UserBillConfigResponse>}
4264
+ */
4265
+ const methodInfo_SniipBillAPIService_UpdateUserBillConfig = new grpc.web.AbstractClientBase.MethodInfo(
4266
+ proto.sniipbillapi.UserBillConfigResponse,
4267
+ /**
4268
+ * @param {!proto.sniipbillapi.UpdateUserBillConfigRequest} request
4269
+ * @return {!Uint8Array}
4270
+ */
4271
+ function(request) {
4272
+ return request.serializeBinary();
4273
+ },
4274
+ proto.sniipbillapi.UserBillConfigResponse.deserializeBinary
4275
+ );
4276
+
4277
+
4278
+ /**
4279
+ * @param {!proto.sniipbillapi.UpdateUserBillConfigRequest} request The
4280
+ * request proto
4281
+ * @param {?Object<string, string>} metadata User defined
4282
+ * call metadata
4283
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.UserBillConfigResponse)}
4284
+ * callback The callback function(error, response)
4285
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.UserBillConfigResponse>|undefined}
4286
+ * The XHR Node Readable Stream
4287
+ */
4288
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.updateUserBillConfig =
4289
+ function(request, metadata, callback) {
4290
+ return this.client_.rpcCall(this.hostname_ +
4291
+ '/sniipbillapi.SniipBillAPIService/UpdateUserBillConfig',
4292
+ request,
4293
+ metadata || {},
4294
+ methodDescriptor_SniipBillAPIService_UpdateUserBillConfig,
4295
+ callback);
4296
+ };
4297
+
4298
+
4299
+ /**
4300
+ * @param {!proto.sniipbillapi.UpdateUserBillConfigRequest} request The
4301
+ * request proto
4302
+ * @param {?Object<string, string>} metadata User defined
4303
+ * call metadata
4304
+ * @return {!Promise<!proto.sniipbillapi.UserBillConfigResponse>}
4305
+ * Promise that resolves to the response
4306
+ */
4307
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.updateUserBillConfig =
4308
+ function(request, metadata) {
4309
+ return this.client_.unaryCall(this.hostname_ +
4310
+ '/sniipbillapi.SniipBillAPIService/UpdateUserBillConfig',
4311
+ request,
4312
+ metadata || {},
4313
+ methodDescriptor_SniipBillAPIService_UpdateUserBillConfig);
4314
+ };
4315
+
4316
+
4317
+ /**
4318
+ * @const
4319
+ * @type {!grpc.web.MethodDescriptor<
4320
+ * !proto.sniipbillapi.UsersForBillerRequest,
4321
+ * !proto.sniipbillapi.GetUsersForBillerResponse>}
4322
+ */
4323
+ const methodDescriptor_SniipBillAPIService_UsersForBiller = new grpc.web.MethodDescriptor(
4324
+ '/sniipbillapi.SniipBillAPIService/UsersForBiller',
4325
+ grpc.web.MethodType.UNARY,
4326
+ proto.sniipbillapi.UsersForBillerRequest,
4327
+ proto.sniipbillapi.GetUsersForBillerResponse,
4328
+ /**
4329
+ * @param {!proto.sniipbillapi.UsersForBillerRequest} request
4330
+ * @return {!Uint8Array}
4331
+ */
4332
+ function(request) {
4333
+ return request.serializeBinary();
4334
+ },
4335
+ proto.sniipbillapi.GetUsersForBillerResponse.deserializeBinary
4336
+ );
4337
+
4338
+
4339
+ /**
4340
+ * @const
4341
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
4342
+ * !proto.sniipbillapi.UsersForBillerRequest,
4343
+ * !proto.sniipbillapi.GetUsersForBillerResponse>}
4344
+ */
4345
+ const methodInfo_SniipBillAPIService_UsersForBiller = new grpc.web.AbstractClientBase.MethodInfo(
4346
+ proto.sniipbillapi.GetUsersForBillerResponse,
4347
+ /**
4348
+ * @param {!proto.sniipbillapi.UsersForBillerRequest} request
4349
+ * @return {!Uint8Array}
4350
+ */
4351
+ function(request) {
4352
+ return request.serializeBinary();
4353
+ },
4354
+ proto.sniipbillapi.GetUsersForBillerResponse.deserializeBinary
4355
+ );
4356
+
4357
+
4358
+ /**
4359
+ * @param {!proto.sniipbillapi.UsersForBillerRequest} request The
4360
+ * request proto
4361
+ * @param {?Object<string, string>} metadata User defined
4362
+ * call metadata
4363
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.GetUsersForBillerResponse)}
4364
+ * callback The callback function(error, response)
4365
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.GetUsersForBillerResponse>|undefined}
4366
+ * The XHR Node Readable Stream
4367
+ */
4368
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.usersForBiller =
4369
+ function(request, metadata, callback) {
4370
+ return this.client_.rpcCall(this.hostname_ +
4371
+ '/sniipbillapi.SniipBillAPIService/UsersForBiller',
4372
+ request,
4373
+ metadata || {},
4374
+ methodDescriptor_SniipBillAPIService_UsersForBiller,
4375
+ callback);
4376
+ };
4377
+
4378
+
4379
+ /**
4380
+ * @param {!proto.sniipbillapi.UsersForBillerRequest} request The
4381
+ * request proto
4382
+ * @param {?Object<string, string>} metadata User defined
4383
+ * call metadata
4384
+ * @return {!Promise<!proto.sniipbillapi.GetUsersForBillerResponse>}
4385
+ * Promise that resolves to the response
4386
+ */
4387
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.usersForBiller =
4388
+ function(request, metadata) {
4389
+ return this.client_.unaryCall(this.hostname_ +
4390
+ '/sniipbillapi.SniipBillAPIService/UsersForBiller',
4391
+ request,
4392
+ metadata || {},
4393
+ methodDescriptor_SniipBillAPIService_UsersForBiller);
4394
+ };
4395
+
4396
+
4397
+ /**
4398
+ * @const
4399
+ * @type {!grpc.web.MethodDescriptor<
4400
+ * !proto.sniipbillapi.UsersForBillerConfigRequest,
4401
+ * !proto.sniipbillapi.GetUsersForBillerResponse>}
4402
+ */
4403
+ const methodDescriptor_SniipBillAPIService_UsersForBillerConfig = new grpc.web.MethodDescriptor(
4404
+ '/sniipbillapi.SniipBillAPIService/UsersForBillerConfig',
4405
+ grpc.web.MethodType.UNARY,
4406
+ proto.sniipbillapi.UsersForBillerConfigRequest,
4407
+ proto.sniipbillapi.GetUsersForBillerResponse,
4408
+ /**
4409
+ * @param {!proto.sniipbillapi.UsersForBillerConfigRequest} request
4410
+ * @return {!Uint8Array}
4411
+ */
4412
+ function(request) {
4413
+ return request.serializeBinary();
4414
+ },
4415
+ proto.sniipbillapi.GetUsersForBillerResponse.deserializeBinary
4416
+ );
4417
+
4418
+
4419
+ /**
4420
+ * @const
4421
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
4422
+ * !proto.sniipbillapi.UsersForBillerConfigRequest,
4423
+ * !proto.sniipbillapi.GetUsersForBillerResponse>}
4424
+ */
4425
+ const methodInfo_SniipBillAPIService_UsersForBillerConfig = new grpc.web.AbstractClientBase.MethodInfo(
4426
+ proto.sniipbillapi.GetUsersForBillerResponse,
4427
+ /**
4428
+ * @param {!proto.sniipbillapi.UsersForBillerConfigRequest} request
4429
+ * @return {!Uint8Array}
4430
+ */
4431
+ function(request) {
4432
+ return request.serializeBinary();
4433
+ },
4434
+ proto.sniipbillapi.GetUsersForBillerResponse.deserializeBinary
4435
+ );
4436
+
4437
+
4438
+ /**
4439
+ * @param {!proto.sniipbillapi.UsersForBillerConfigRequest} request The
4440
+ * request proto
4441
+ * @param {?Object<string, string>} metadata User defined
4442
+ * call metadata
4443
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.GetUsersForBillerResponse)}
4444
+ * callback The callback function(error, response)
4445
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.GetUsersForBillerResponse>|undefined}
4446
+ * The XHR Node Readable Stream
4447
+ */
4448
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.usersForBillerConfig =
4449
+ function(request, metadata, callback) {
4450
+ return this.client_.rpcCall(this.hostname_ +
4451
+ '/sniipbillapi.SniipBillAPIService/UsersForBillerConfig',
4452
+ request,
4453
+ metadata || {},
4454
+ methodDescriptor_SniipBillAPIService_UsersForBillerConfig,
4455
+ callback);
4456
+ };
4457
+
4458
+
4459
+ /**
4460
+ * @param {!proto.sniipbillapi.UsersForBillerConfigRequest} request The
4461
+ * request proto
4462
+ * @param {?Object<string, string>} metadata User defined
4463
+ * call metadata
4464
+ * @return {!Promise<!proto.sniipbillapi.GetUsersForBillerResponse>}
4465
+ * Promise that resolves to the response
4466
+ */
4467
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.usersForBillerConfig =
4468
+ function(request, metadata) {
4469
+ return this.client_.unaryCall(this.hostname_ +
4470
+ '/sniipbillapi.SniipBillAPIService/UsersForBillerConfig',
4471
+ request,
4472
+ metadata || {},
4473
+ methodDescriptor_SniipBillAPIService_UsersForBillerConfig);
4474
+ };
4475
+
4476
+
4477
+ /**
4478
+ * @const
4479
+ * @type {!grpc.web.MethodDescriptor<
4480
+ * !proto.sniipbillapi.ValidateBillOwnerRequest,
4481
+ * !proto.sniipbillapi.ResponseCode>}
4482
+ */
4483
+ const methodDescriptor_SniipBillAPIService_ValidateBillOwner = new grpc.web.MethodDescriptor(
4484
+ '/sniipbillapi.SniipBillAPIService/ValidateBillOwner',
4485
+ grpc.web.MethodType.UNARY,
4486
+ proto.sniipbillapi.ValidateBillOwnerRequest,
4487
+ proto.sniipbillapi.ResponseCode,
4488
+ /**
4489
+ * @param {!proto.sniipbillapi.ValidateBillOwnerRequest} request
4490
+ * @return {!Uint8Array}
4491
+ */
4492
+ function(request) {
4493
+ return request.serializeBinary();
4494
+ },
4495
+ proto.sniipbillapi.ResponseCode.deserializeBinary
4496
+ );
4497
+
4498
+
4499
+ /**
4500
+ * @const
4501
+ * @type {!grpc.web.AbstractClientBase.MethodInfo<
4502
+ * !proto.sniipbillapi.ValidateBillOwnerRequest,
4503
+ * !proto.sniipbillapi.ResponseCode>}
4504
+ */
4505
+ const methodInfo_SniipBillAPIService_ValidateBillOwner = new grpc.web.AbstractClientBase.MethodInfo(
4506
+ proto.sniipbillapi.ResponseCode,
4507
+ /**
4508
+ * @param {!proto.sniipbillapi.ValidateBillOwnerRequest} request
4509
+ * @return {!Uint8Array}
4510
+ */
4511
+ function(request) {
4512
+ return request.serializeBinary();
4513
+ },
4514
+ proto.sniipbillapi.ResponseCode.deserializeBinary
4515
+ );
4516
+
4517
+
4518
+ /**
4519
+ * @param {!proto.sniipbillapi.ValidateBillOwnerRequest} request The
4520
+ * request proto
4521
+ * @param {?Object<string, string>} metadata User defined
4522
+ * call metadata
4523
+ * @param {function(?grpc.web.Error, ?proto.sniipbillapi.ResponseCode)}
4524
+ * callback The callback function(error, response)
4525
+ * @return {!grpc.web.ClientReadableStream<!proto.sniipbillapi.ResponseCode>|undefined}
4526
+ * The XHR Node Readable Stream
4527
+ */
4528
+ proto.sniipbillapi.SniipBillAPIServiceClient.prototype.validateBillOwner =
4529
+ function(request, metadata, callback) {
4530
+ return this.client_.rpcCall(this.hostname_ +
4531
+ '/sniipbillapi.SniipBillAPIService/ValidateBillOwner',
4532
+ request,
4533
+ metadata || {},
4534
+ methodDescriptor_SniipBillAPIService_ValidateBillOwner,
4535
+ callback);
4536
+ };
4537
+
4538
+
4539
+ /**
4540
+ * @param {!proto.sniipbillapi.ValidateBillOwnerRequest} request The
4541
+ * request proto
4542
+ * @param {?Object<string, string>} metadata User defined
4543
+ * call metadata
4544
+ * @return {!Promise<!proto.sniipbillapi.ResponseCode>}
4545
+ * Promise that resolves to the response
4546
+ */
4547
+ proto.sniipbillapi.SniipBillAPIServicePromiseClient.prototype.validateBillOwner =
4548
+ function(request, metadata) {
4549
+ return this.client_.unaryCall(this.hostname_ +
4550
+ '/sniipbillapi.SniipBillAPIService/ValidateBillOwner',
4551
+ request,
4552
+ metadata || {},
4553
+ methodDescriptor_SniipBillAPIService_ValidateBillOwner);
4554
+ };
4555
+
4556
+
4557
+ module.exports = proto.sniipbillapi;
4558
+