@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.
- package/dependancies/service_grpc_web_pb.js +4558 -0
- package/dependancies/service_pb.js +33617 -0
- package/package.json +1 -1
|
@@ -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
|
+
|