@sniipwebmaster/payroll-service-client-grpcweb 25.7.13 → 25.7.35
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 +1186 -27
- package/dependancies/service_pb.js +14952 -47
- package/package.json +1 -1
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* @fileoverview gRPC-Web generated client stub for
|
|
2
|
+
* @fileoverview gRPC-Web generated client stub for payrollserviceapi
|
|
3
3
|
* @enhanceable
|
|
4
4
|
* @public
|
|
5
5
|
*/
|
|
@@ -28,7 +28,7 @@ var google_type_decimal_pb = require('./google/type/decimal_pb.js')
|
|
|
28
28
|
|
|
29
29
|
var protoc$gen$openapiv2_options_annotations_pb = require('./protoc-gen-openapiv2/options/annotations_pb.js')
|
|
30
30
|
const proto = {};
|
|
31
|
-
proto.
|
|
31
|
+
proto.payrollserviceapi = require('./service_pb.js');
|
|
32
32
|
|
|
33
33
|
/**
|
|
34
34
|
* @param {string} hostname
|
|
@@ -38,7 +38,7 @@ proto.worldpayserviceapi = require('./service_pb.js');
|
|
|
38
38
|
* @struct
|
|
39
39
|
* @final
|
|
40
40
|
*/
|
|
41
|
-
proto.
|
|
41
|
+
proto.payrollserviceapi.PayrollServiceClient =
|
|
42
42
|
function(hostname, credentials, options) {
|
|
43
43
|
if (!options) options = {};
|
|
44
44
|
options.format = 'text';
|
|
@@ -64,7 +64,7 @@ proto.worldpayserviceapi.PayrollServiceClient =
|
|
|
64
64
|
* @struct
|
|
65
65
|
* @final
|
|
66
66
|
*/
|
|
67
|
-
proto.
|
|
67
|
+
proto.payrollserviceapi.PayrollServicePromiseClient =
|
|
68
68
|
function(hostname, credentials, options) {
|
|
69
69
|
if (!options) options = {};
|
|
70
70
|
options.format = 'text';
|
|
@@ -86,13 +86,13 @@ proto.worldpayserviceapi.PayrollServicePromiseClient =
|
|
|
86
86
|
* @const
|
|
87
87
|
* @type {!grpc.web.MethodDescriptor<
|
|
88
88
|
* !proto.google.protobuf.Empty,
|
|
89
|
-
* !proto.
|
|
89
|
+
* !proto.payrollserviceapi.ResponseCode>}
|
|
90
90
|
*/
|
|
91
91
|
const methodDescriptor_PayrollService_Health = new grpc.web.MethodDescriptor(
|
|
92
|
-
'/
|
|
92
|
+
'/payrollserviceapi.PayrollService/Health',
|
|
93
93
|
grpc.web.MethodType.UNARY,
|
|
94
94
|
google_protobuf_empty_pb.Empty,
|
|
95
|
-
proto.
|
|
95
|
+
proto.payrollserviceapi.ResponseCode,
|
|
96
96
|
/**
|
|
97
97
|
* @param {!proto.google.protobuf.Empty} request
|
|
98
98
|
* @return {!Uint8Array}
|
|
@@ -100,7 +100,7 @@ const methodDescriptor_PayrollService_Health = new grpc.web.MethodDescriptor(
|
|
|
100
100
|
function(request) {
|
|
101
101
|
return request.serializeBinary();
|
|
102
102
|
},
|
|
103
|
-
proto.
|
|
103
|
+
proto.payrollserviceapi.ResponseCode.deserializeBinary
|
|
104
104
|
);
|
|
105
105
|
|
|
106
106
|
|
|
@@ -109,15 +109,15 @@ const methodDescriptor_PayrollService_Health = new grpc.web.MethodDescriptor(
|
|
|
109
109
|
* request proto
|
|
110
110
|
* @param {?Object<string, string>} metadata User defined
|
|
111
111
|
* call metadata
|
|
112
|
-
* @param {function(?grpc.web.RpcError, ?proto.
|
|
112
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.ResponseCode)}
|
|
113
113
|
* callback The callback function(error, response)
|
|
114
|
-
* @return {!grpc.web.ClientReadableStream<!proto.
|
|
114
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.ResponseCode>|undefined}
|
|
115
115
|
* The XHR Node Readable Stream
|
|
116
116
|
*/
|
|
117
|
-
proto.
|
|
117
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.health =
|
|
118
118
|
function(request, metadata, callback) {
|
|
119
119
|
return this.client_.rpcCall(this.hostname_ +
|
|
120
|
-
'/
|
|
120
|
+
'/payrollserviceapi.PayrollService/Health',
|
|
121
121
|
request,
|
|
122
122
|
metadata || {},
|
|
123
123
|
methodDescriptor_PayrollService_Health,
|
|
@@ -130,13 +130,13 @@ proto.worldpayserviceapi.PayrollServiceClient.prototype.health =
|
|
|
130
130
|
* request proto
|
|
131
131
|
* @param {?Object<string, string>=} metadata User defined
|
|
132
132
|
* call metadata
|
|
133
|
-
* @return {!Promise<!proto.
|
|
133
|
+
* @return {!Promise<!proto.payrollserviceapi.ResponseCode>}
|
|
134
134
|
* Promise that resolves to the response
|
|
135
135
|
*/
|
|
136
|
-
proto.
|
|
136
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.health =
|
|
137
137
|
function(request, metadata) {
|
|
138
138
|
return this.client_.unaryCall(this.hostname_ +
|
|
139
|
-
'/
|
|
139
|
+
'/payrollserviceapi.PayrollService/Health',
|
|
140
140
|
request,
|
|
141
141
|
metadata || {},
|
|
142
142
|
methodDescriptor_PayrollService_Health);
|
|
@@ -147,13 +147,13 @@ proto.worldpayserviceapi.PayrollServicePromiseClient.prototype.health =
|
|
|
147
147
|
* @const
|
|
148
148
|
* @type {!grpc.web.MethodDescriptor<
|
|
149
149
|
* !proto.google.protobuf.Empty,
|
|
150
|
-
* !proto.
|
|
150
|
+
* !proto.payrollserviceapi.ResponseCode>}
|
|
151
151
|
*/
|
|
152
152
|
const methodDescriptor_PayrollService_LocalHealth = new grpc.web.MethodDescriptor(
|
|
153
|
-
'/
|
|
153
|
+
'/payrollserviceapi.PayrollService/LocalHealth',
|
|
154
154
|
grpc.web.MethodType.UNARY,
|
|
155
155
|
google_protobuf_empty_pb.Empty,
|
|
156
|
-
proto.
|
|
156
|
+
proto.payrollserviceapi.ResponseCode,
|
|
157
157
|
/**
|
|
158
158
|
* @param {!proto.google.protobuf.Empty} request
|
|
159
159
|
* @return {!Uint8Array}
|
|
@@ -161,7 +161,7 @@ const methodDescriptor_PayrollService_LocalHealth = new grpc.web.MethodDescripto
|
|
|
161
161
|
function(request) {
|
|
162
162
|
return request.serializeBinary();
|
|
163
163
|
},
|
|
164
|
-
proto.
|
|
164
|
+
proto.payrollserviceapi.ResponseCode.deserializeBinary
|
|
165
165
|
);
|
|
166
166
|
|
|
167
167
|
|
|
@@ -170,15 +170,15 @@ const methodDescriptor_PayrollService_LocalHealth = new grpc.web.MethodDescripto
|
|
|
170
170
|
* request proto
|
|
171
171
|
* @param {?Object<string, string>} metadata User defined
|
|
172
172
|
* call metadata
|
|
173
|
-
* @param {function(?grpc.web.RpcError, ?proto.
|
|
173
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.ResponseCode)}
|
|
174
174
|
* callback The callback function(error, response)
|
|
175
|
-
* @return {!grpc.web.ClientReadableStream<!proto.
|
|
175
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.ResponseCode>|undefined}
|
|
176
176
|
* The XHR Node Readable Stream
|
|
177
177
|
*/
|
|
178
|
-
proto.
|
|
178
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.localHealth =
|
|
179
179
|
function(request, metadata, callback) {
|
|
180
180
|
return this.client_.rpcCall(this.hostname_ +
|
|
181
|
-
'/
|
|
181
|
+
'/payrollserviceapi.PayrollService/LocalHealth',
|
|
182
182
|
request,
|
|
183
183
|
metadata || {},
|
|
184
184
|
methodDescriptor_PayrollService_LocalHealth,
|
|
@@ -191,18 +191,1177 @@ proto.worldpayserviceapi.PayrollServiceClient.prototype.localHealth =
|
|
|
191
191
|
* request proto
|
|
192
192
|
* @param {?Object<string, string>=} metadata User defined
|
|
193
193
|
* call metadata
|
|
194
|
-
* @return {!Promise<!proto.
|
|
194
|
+
* @return {!Promise<!proto.payrollserviceapi.ResponseCode>}
|
|
195
195
|
* Promise that resolves to the response
|
|
196
196
|
*/
|
|
197
|
-
proto.
|
|
197
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.localHealth =
|
|
198
198
|
function(request, metadata) {
|
|
199
199
|
return this.client_.unaryCall(this.hostname_ +
|
|
200
|
-
'/
|
|
200
|
+
'/payrollserviceapi.PayrollService/LocalHealth',
|
|
201
201
|
request,
|
|
202
202
|
metadata || {},
|
|
203
203
|
methodDescriptor_PayrollService_LocalHealth);
|
|
204
204
|
};
|
|
205
205
|
|
|
206
206
|
|
|
207
|
-
|
|
207
|
+
/**
|
|
208
|
+
* @const
|
|
209
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
210
|
+
* !proto.payrollserviceapi.ImportABAFileRequest,
|
|
211
|
+
* !proto.payrollserviceapi.ImportABAFileResponse>}
|
|
212
|
+
*/
|
|
213
|
+
const methodDescriptor_PayrollService_ImportABAFile = new grpc.web.MethodDescriptor(
|
|
214
|
+
'/payrollserviceapi.PayrollService/ImportABAFile',
|
|
215
|
+
grpc.web.MethodType.UNARY,
|
|
216
|
+
proto.payrollserviceapi.ImportABAFileRequest,
|
|
217
|
+
proto.payrollserviceapi.ImportABAFileResponse,
|
|
218
|
+
/**
|
|
219
|
+
* @param {!proto.payrollserviceapi.ImportABAFileRequest} request
|
|
220
|
+
* @return {!Uint8Array}
|
|
221
|
+
*/
|
|
222
|
+
function(request) {
|
|
223
|
+
return request.serializeBinary();
|
|
224
|
+
},
|
|
225
|
+
proto.payrollserviceapi.ImportABAFileResponse.deserializeBinary
|
|
226
|
+
);
|
|
227
|
+
|
|
228
|
+
|
|
229
|
+
/**
|
|
230
|
+
* @param {!proto.payrollserviceapi.ImportABAFileRequest} request The
|
|
231
|
+
* request proto
|
|
232
|
+
* @param {?Object<string, string>} metadata User defined
|
|
233
|
+
* call metadata
|
|
234
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.ImportABAFileResponse)}
|
|
235
|
+
* callback The callback function(error, response)
|
|
236
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.ImportABAFileResponse>|undefined}
|
|
237
|
+
* The XHR Node Readable Stream
|
|
238
|
+
*/
|
|
239
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.importABAFile =
|
|
240
|
+
function(request, metadata, callback) {
|
|
241
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
242
|
+
'/payrollserviceapi.PayrollService/ImportABAFile',
|
|
243
|
+
request,
|
|
244
|
+
metadata || {},
|
|
245
|
+
methodDescriptor_PayrollService_ImportABAFile,
|
|
246
|
+
callback);
|
|
247
|
+
};
|
|
248
|
+
|
|
249
|
+
|
|
250
|
+
/**
|
|
251
|
+
* @param {!proto.payrollserviceapi.ImportABAFileRequest} request The
|
|
252
|
+
* request proto
|
|
253
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
254
|
+
* call metadata
|
|
255
|
+
* @return {!Promise<!proto.payrollserviceapi.ImportABAFileResponse>}
|
|
256
|
+
* Promise that resolves to the response
|
|
257
|
+
*/
|
|
258
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.importABAFile =
|
|
259
|
+
function(request, metadata) {
|
|
260
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
261
|
+
'/payrollserviceapi.PayrollService/ImportABAFile',
|
|
262
|
+
request,
|
|
263
|
+
metadata || {},
|
|
264
|
+
methodDescriptor_PayrollService_ImportABAFile);
|
|
265
|
+
};
|
|
266
|
+
|
|
267
|
+
|
|
268
|
+
/**
|
|
269
|
+
* @const
|
|
270
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
271
|
+
* !proto.payrollserviceapi.MatchEmployeesRequest,
|
|
272
|
+
* !proto.payrollserviceapi.MatchEmployeesResponse>}
|
|
273
|
+
*/
|
|
274
|
+
const methodDescriptor_PayrollService_MatchEmployees = new grpc.web.MethodDescriptor(
|
|
275
|
+
'/payrollserviceapi.PayrollService/MatchEmployees',
|
|
276
|
+
grpc.web.MethodType.UNARY,
|
|
277
|
+
proto.payrollserviceapi.MatchEmployeesRequest,
|
|
278
|
+
proto.payrollserviceapi.MatchEmployeesResponse,
|
|
279
|
+
/**
|
|
280
|
+
* @param {!proto.payrollserviceapi.MatchEmployeesRequest} request
|
|
281
|
+
* @return {!Uint8Array}
|
|
282
|
+
*/
|
|
283
|
+
function(request) {
|
|
284
|
+
return request.serializeBinary();
|
|
285
|
+
},
|
|
286
|
+
proto.payrollserviceapi.MatchEmployeesResponse.deserializeBinary
|
|
287
|
+
);
|
|
288
|
+
|
|
289
|
+
|
|
290
|
+
/**
|
|
291
|
+
* @param {!proto.payrollserviceapi.MatchEmployeesRequest} request The
|
|
292
|
+
* request proto
|
|
293
|
+
* @param {?Object<string, string>} metadata User defined
|
|
294
|
+
* call metadata
|
|
295
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.MatchEmployeesResponse)}
|
|
296
|
+
* callback The callback function(error, response)
|
|
297
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.MatchEmployeesResponse>|undefined}
|
|
298
|
+
* The XHR Node Readable Stream
|
|
299
|
+
*/
|
|
300
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.matchEmployees =
|
|
301
|
+
function(request, metadata, callback) {
|
|
302
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
303
|
+
'/payrollserviceapi.PayrollService/MatchEmployees',
|
|
304
|
+
request,
|
|
305
|
+
metadata || {},
|
|
306
|
+
methodDescriptor_PayrollService_MatchEmployees,
|
|
307
|
+
callback);
|
|
308
|
+
};
|
|
309
|
+
|
|
310
|
+
|
|
311
|
+
/**
|
|
312
|
+
* @param {!proto.payrollserviceapi.MatchEmployeesRequest} request The
|
|
313
|
+
* request proto
|
|
314
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
315
|
+
* call metadata
|
|
316
|
+
* @return {!Promise<!proto.payrollserviceapi.MatchEmployeesResponse>}
|
|
317
|
+
* Promise that resolves to the response
|
|
318
|
+
*/
|
|
319
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.matchEmployees =
|
|
320
|
+
function(request, metadata) {
|
|
321
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
322
|
+
'/payrollserviceapi.PayrollService/MatchEmployees',
|
|
323
|
+
request,
|
|
324
|
+
metadata || {},
|
|
325
|
+
methodDescriptor_PayrollService_MatchEmployees);
|
|
326
|
+
};
|
|
327
|
+
|
|
328
|
+
|
|
329
|
+
/**
|
|
330
|
+
* @const
|
|
331
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
332
|
+
* !proto.payrollserviceapi.GetBatchDetailsRequest,
|
|
333
|
+
* !proto.payrollserviceapi.GetBatchDetailsResponse>}
|
|
334
|
+
*/
|
|
335
|
+
const methodDescriptor_PayrollService_GetBatchDetails = new grpc.web.MethodDescriptor(
|
|
336
|
+
'/payrollserviceapi.PayrollService/GetBatchDetails',
|
|
337
|
+
grpc.web.MethodType.UNARY,
|
|
338
|
+
proto.payrollserviceapi.GetBatchDetailsRequest,
|
|
339
|
+
proto.payrollserviceapi.GetBatchDetailsResponse,
|
|
340
|
+
/**
|
|
341
|
+
* @param {!proto.payrollserviceapi.GetBatchDetailsRequest} request
|
|
342
|
+
* @return {!Uint8Array}
|
|
343
|
+
*/
|
|
344
|
+
function(request) {
|
|
345
|
+
return request.serializeBinary();
|
|
346
|
+
},
|
|
347
|
+
proto.payrollserviceapi.GetBatchDetailsResponse.deserializeBinary
|
|
348
|
+
);
|
|
349
|
+
|
|
350
|
+
|
|
351
|
+
/**
|
|
352
|
+
* @param {!proto.payrollserviceapi.GetBatchDetailsRequest} request The
|
|
353
|
+
* request proto
|
|
354
|
+
* @param {?Object<string, string>} metadata User defined
|
|
355
|
+
* call metadata
|
|
356
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.GetBatchDetailsResponse)}
|
|
357
|
+
* callback The callback function(error, response)
|
|
358
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.GetBatchDetailsResponse>|undefined}
|
|
359
|
+
* The XHR Node Readable Stream
|
|
360
|
+
*/
|
|
361
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.getBatchDetails =
|
|
362
|
+
function(request, metadata, callback) {
|
|
363
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
364
|
+
'/payrollserviceapi.PayrollService/GetBatchDetails',
|
|
365
|
+
request,
|
|
366
|
+
metadata || {},
|
|
367
|
+
methodDescriptor_PayrollService_GetBatchDetails,
|
|
368
|
+
callback);
|
|
369
|
+
};
|
|
370
|
+
|
|
371
|
+
|
|
372
|
+
/**
|
|
373
|
+
* @param {!proto.payrollserviceapi.GetBatchDetailsRequest} request The
|
|
374
|
+
* request proto
|
|
375
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
376
|
+
* call metadata
|
|
377
|
+
* @return {!Promise<!proto.payrollserviceapi.GetBatchDetailsResponse>}
|
|
378
|
+
* Promise that resolves to the response
|
|
379
|
+
*/
|
|
380
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.getBatchDetails =
|
|
381
|
+
function(request, metadata) {
|
|
382
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
383
|
+
'/payrollserviceapi.PayrollService/GetBatchDetails',
|
|
384
|
+
request,
|
|
385
|
+
metadata || {},
|
|
386
|
+
methodDescriptor_PayrollService_GetBatchDetails);
|
|
387
|
+
};
|
|
388
|
+
|
|
389
|
+
|
|
390
|
+
/**
|
|
391
|
+
* @const
|
|
392
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
393
|
+
* !proto.payrollserviceapi.ExecutePayrollRequest,
|
|
394
|
+
* !proto.payrollserviceapi.ExecutePayrollResponse>}
|
|
395
|
+
*/
|
|
396
|
+
const methodDescriptor_PayrollService_ExecutePayroll = new grpc.web.MethodDescriptor(
|
|
397
|
+
'/payrollserviceapi.PayrollService/ExecutePayroll',
|
|
398
|
+
grpc.web.MethodType.UNARY,
|
|
399
|
+
proto.payrollserviceapi.ExecutePayrollRequest,
|
|
400
|
+
proto.payrollserviceapi.ExecutePayrollResponse,
|
|
401
|
+
/**
|
|
402
|
+
* @param {!proto.payrollserviceapi.ExecutePayrollRequest} request
|
|
403
|
+
* @return {!Uint8Array}
|
|
404
|
+
*/
|
|
405
|
+
function(request) {
|
|
406
|
+
return request.serializeBinary();
|
|
407
|
+
},
|
|
408
|
+
proto.payrollserviceapi.ExecutePayrollResponse.deserializeBinary
|
|
409
|
+
);
|
|
410
|
+
|
|
411
|
+
|
|
412
|
+
/**
|
|
413
|
+
* @param {!proto.payrollserviceapi.ExecutePayrollRequest} request The
|
|
414
|
+
* request proto
|
|
415
|
+
* @param {?Object<string, string>} metadata User defined
|
|
416
|
+
* call metadata
|
|
417
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.ExecutePayrollResponse)}
|
|
418
|
+
* callback The callback function(error, response)
|
|
419
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.ExecutePayrollResponse>|undefined}
|
|
420
|
+
* The XHR Node Readable Stream
|
|
421
|
+
*/
|
|
422
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.executePayroll =
|
|
423
|
+
function(request, metadata, callback) {
|
|
424
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
425
|
+
'/payrollserviceapi.PayrollService/ExecutePayroll',
|
|
426
|
+
request,
|
|
427
|
+
metadata || {},
|
|
428
|
+
methodDescriptor_PayrollService_ExecutePayroll,
|
|
429
|
+
callback);
|
|
430
|
+
};
|
|
431
|
+
|
|
432
|
+
|
|
433
|
+
/**
|
|
434
|
+
* @param {!proto.payrollserviceapi.ExecutePayrollRequest} request The
|
|
435
|
+
* request proto
|
|
436
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
437
|
+
* call metadata
|
|
438
|
+
* @return {!Promise<!proto.payrollserviceapi.ExecutePayrollResponse>}
|
|
439
|
+
* Promise that resolves to the response
|
|
440
|
+
*/
|
|
441
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.executePayroll =
|
|
442
|
+
function(request, metadata) {
|
|
443
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
444
|
+
'/payrollserviceapi.PayrollService/ExecutePayroll',
|
|
445
|
+
request,
|
|
446
|
+
metadata || {},
|
|
447
|
+
methodDescriptor_PayrollService_ExecutePayroll);
|
|
448
|
+
};
|
|
449
|
+
|
|
450
|
+
|
|
451
|
+
/**
|
|
452
|
+
* @const
|
|
453
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
454
|
+
* !proto.payrollserviceapi.ListABAFilesRequest,
|
|
455
|
+
* !proto.payrollserviceapi.ListABAFilesResponse>}
|
|
456
|
+
*/
|
|
457
|
+
const methodDescriptor_PayrollService_ListABAFiles = new grpc.web.MethodDescriptor(
|
|
458
|
+
'/payrollserviceapi.PayrollService/ListABAFiles',
|
|
459
|
+
grpc.web.MethodType.UNARY,
|
|
460
|
+
proto.payrollserviceapi.ListABAFilesRequest,
|
|
461
|
+
proto.payrollserviceapi.ListABAFilesResponse,
|
|
462
|
+
/**
|
|
463
|
+
* @param {!proto.payrollserviceapi.ListABAFilesRequest} request
|
|
464
|
+
* @return {!Uint8Array}
|
|
465
|
+
*/
|
|
466
|
+
function(request) {
|
|
467
|
+
return request.serializeBinary();
|
|
468
|
+
},
|
|
469
|
+
proto.payrollserviceapi.ListABAFilesResponse.deserializeBinary
|
|
470
|
+
);
|
|
471
|
+
|
|
472
|
+
|
|
473
|
+
/**
|
|
474
|
+
* @param {!proto.payrollserviceapi.ListABAFilesRequest} request The
|
|
475
|
+
* request proto
|
|
476
|
+
* @param {?Object<string, string>} metadata User defined
|
|
477
|
+
* call metadata
|
|
478
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.ListABAFilesResponse)}
|
|
479
|
+
* callback The callback function(error, response)
|
|
480
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.ListABAFilesResponse>|undefined}
|
|
481
|
+
* The XHR Node Readable Stream
|
|
482
|
+
*/
|
|
483
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.listABAFiles =
|
|
484
|
+
function(request, metadata, callback) {
|
|
485
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
486
|
+
'/payrollserviceapi.PayrollService/ListABAFiles',
|
|
487
|
+
request,
|
|
488
|
+
metadata || {},
|
|
489
|
+
methodDescriptor_PayrollService_ListABAFiles,
|
|
490
|
+
callback);
|
|
491
|
+
};
|
|
492
|
+
|
|
493
|
+
|
|
494
|
+
/**
|
|
495
|
+
* @param {!proto.payrollserviceapi.ListABAFilesRequest} request The
|
|
496
|
+
* request proto
|
|
497
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
498
|
+
* call metadata
|
|
499
|
+
* @return {!Promise<!proto.payrollserviceapi.ListABAFilesResponse>}
|
|
500
|
+
* Promise that resolves to the response
|
|
501
|
+
*/
|
|
502
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.listABAFiles =
|
|
503
|
+
function(request, metadata) {
|
|
504
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
505
|
+
'/payrollserviceapi.PayrollService/ListABAFiles',
|
|
506
|
+
request,
|
|
507
|
+
metadata || {},
|
|
508
|
+
methodDescriptor_PayrollService_ListABAFiles);
|
|
509
|
+
};
|
|
510
|
+
|
|
511
|
+
|
|
512
|
+
/**
|
|
513
|
+
* @const
|
|
514
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
515
|
+
* !proto.payrollserviceapi.GetABAFileDetailsRequest,
|
|
516
|
+
* !proto.payrollserviceapi.GetABAFileDetailsResponse>}
|
|
517
|
+
*/
|
|
518
|
+
const methodDescriptor_PayrollService_GetABAFileDetails = new grpc.web.MethodDescriptor(
|
|
519
|
+
'/payrollserviceapi.PayrollService/GetABAFileDetails',
|
|
520
|
+
grpc.web.MethodType.UNARY,
|
|
521
|
+
proto.payrollserviceapi.GetABAFileDetailsRequest,
|
|
522
|
+
proto.payrollserviceapi.GetABAFileDetailsResponse,
|
|
523
|
+
/**
|
|
524
|
+
* @param {!proto.payrollserviceapi.GetABAFileDetailsRequest} request
|
|
525
|
+
* @return {!Uint8Array}
|
|
526
|
+
*/
|
|
527
|
+
function(request) {
|
|
528
|
+
return request.serializeBinary();
|
|
529
|
+
},
|
|
530
|
+
proto.payrollserviceapi.GetABAFileDetailsResponse.deserializeBinary
|
|
531
|
+
);
|
|
532
|
+
|
|
533
|
+
|
|
534
|
+
/**
|
|
535
|
+
* @param {!proto.payrollserviceapi.GetABAFileDetailsRequest} request The
|
|
536
|
+
* request proto
|
|
537
|
+
* @param {?Object<string, string>} metadata User defined
|
|
538
|
+
* call metadata
|
|
539
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.GetABAFileDetailsResponse)}
|
|
540
|
+
* callback The callback function(error, response)
|
|
541
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.GetABAFileDetailsResponse>|undefined}
|
|
542
|
+
* The XHR Node Readable Stream
|
|
543
|
+
*/
|
|
544
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.getABAFileDetails =
|
|
545
|
+
function(request, metadata, callback) {
|
|
546
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
547
|
+
'/payrollserviceapi.PayrollService/GetABAFileDetails',
|
|
548
|
+
request,
|
|
549
|
+
metadata || {},
|
|
550
|
+
methodDescriptor_PayrollService_GetABAFileDetails,
|
|
551
|
+
callback);
|
|
552
|
+
};
|
|
553
|
+
|
|
554
|
+
|
|
555
|
+
/**
|
|
556
|
+
* @param {!proto.payrollserviceapi.GetABAFileDetailsRequest} request The
|
|
557
|
+
* request proto
|
|
558
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
559
|
+
* call metadata
|
|
560
|
+
* @return {!Promise<!proto.payrollserviceapi.GetABAFileDetailsResponse>}
|
|
561
|
+
* Promise that resolves to the response
|
|
562
|
+
*/
|
|
563
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.getABAFileDetails =
|
|
564
|
+
function(request, metadata) {
|
|
565
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
566
|
+
'/payrollserviceapi.PayrollService/GetABAFileDetails',
|
|
567
|
+
request,
|
|
568
|
+
metadata || {},
|
|
569
|
+
methodDescriptor_PayrollService_GetABAFileDetails);
|
|
570
|
+
};
|
|
571
|
+
|
|
572
|
+
|
|
573
|
+
/**
|
|
574
|
+
* @const
|
|
575
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
576
|
+
* !proto.payrollserviceapi.ExecutePayrollWorkflowRequest,
|
|
577
|
+
* !proto.payrollserviceapi.ExecutePayrollWorkflowResponse>}
|
|
578
|
+
*/
|
|
579
|
+
const methodDescriptor_PayrollService_ExecutePayrollWorkflow = new grpc.web.MethodDescriptor(
|
|
580
|
+
'/payrollserviceapi.PayrollService/ExecutePayrollWorkflow',
|
|
581
|
+
grpc.web.MethodType.UNARY,
|
|
582
|
+
proto.payrollserviceapi.ExecutePayrollWorkflowRequest,
|
|
583
|
+
proto.payrollserviceapi.ExecutePayrollWorkflowResponse,
|
|
584
|
+
/**
|
|
585
|
+
* @param {!proto.payrollserviceapi.ExecutePayrollWorkflowRequest} request
|
|
586
|
+
* @return {!Uint8Array}
|
|
587
|
+
*/
|
|
588
|
+
function(request) {
|
|
589
|
+
return request.serializeBinary();
|
|
590
|
+
},
|
|
591
|
+
proto.payrollserviceapi.ExecutePayrollWorkflowResponse.deserializeBinary
|
|
592
|
+
);
|
|
593
|
+
|
|
594
|
+
|
|
595
|
+
/**
|
|
596
|
+
* @param {!proto.payrollserviceapi.ExecutePayrollWorkflowRequest} request The
|
|
597
|
+
* request proto
|
|
598
|
+
* @param {?Object<string, string>} metadata User defined
|
|
599
|
+
* call metadata
|
|
600
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.ExecutePayrollWorkflowResponse)}
|
|
601
|
+
* callback The callback function(error, response)
|
|
602
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.ExecutePayrollWorkflowResponse>|undefined}
|
|
603
|
+
* The XHR Node Readable Stream
|
|
604
|
+
*/
|
|
605
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.executePayrollWorkflow =
|
|
606
|
+
function(request, metadata, callback) {
|
|
607
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
608
|
+
'/payrollserviceapi.PayrollService/ExecutePayrollWorkflow',
|
|
609
|
+
request,
|
|
610
|
+
metadata || {},
|
|
611
|
+
methodDescriptor_PayrollService_ExecutePayrollWorkflow,
|
|
612
|
+
callback);
|
|
613
|
+
};
|
|
614
|
+
|
|
615
|
+
|
|
616
|
+
/**
|
|
617
|
+
* @param {!proto.payrollserviceapi.ExecutePayrollWorkflowRequest} request The
|
|
618
|
+
* request proto
|
|
619
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
620
|
+
* call metadata
|
|
621
|
+
* @return {!Promise<!proto.payrollserviceapi.ExecutePayrollWorkflowResponse>}
|
|
622
|
+
* Promise that resolves to the response
|
|
623
|
+
*/
|
|
624
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.executePayrollWorkflow =
|
|
625
|
+
function(request, metadata) {
|
|
626
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
627
|
+
'/payrollserviceapi.PayrollService/ExecutePayrollWorkflow',
|
|
628
|
+
request,
|
|
629
|
+
metadata || {},
|
|
630
|
+
methodDescriptor_PayrollService_ExecutePayrollWorkflow);
|
|
631
|
+
};
|
|
632
|
+
|
|
633
|
+
|
|
634
|
+
/**
|
|
635
|
+
* @const
|
|
636
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
637
|
+
* !proto.payrollserviceapi.CreateBusinessRequest,
|
|
638
|
+
* !proto.payrollserviceapi.CreateBusinessResponse>}
|
|
639
|
+
*/
|
|
640
|
+
const methodDescriptor_PayrollService_CreateBusiness = new grpc.web.MethodDescriptor(
|
|
641
|
+
'/payrollserviceapi.PayrollService/CreateBusiness',
|
|
642
|
+
grpc.web.MethodType.UNARY,
|
|
643
|
+
proto.payrollserviceapi.CreateBusinessRequest,
|
|
644
|
+
proto.payrollserviceapi.CreateBusinessResponse,
|
|
645
|
+
/**
|
|
646
|
+
* @param {!proto.payrollserviceapi.CreateBusinessRequest} request
|
|
647
|
+
* @return {!Uint8Array}
|
|
648
|
+
*/
|
|
649
|
+
function(request) {
|
|
650
|
+
return request.serializeBinary();
|
|
651
|
+
},
|
|
652
|
+
proto.payrollserviceapi.CreateBusinessResponse.deserializeBinary
|
|
653
|
+
);
|
|
654
|
+
|
|
655
|
+
|
|
656
|
+
/**
|
|
657
|
+
* @param {!proto.payrollserviceapi.CreateBusinessRequest} request The
|
|
658
|
+
* request proto
|
|
659
|
+
* @param {?Object<string, string>} metadata User defined
|
|
660
|
+
* call metadata
|
|
661
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.CreateBusinessResponse)}
|
|
662
|
+
* callback The callback function(error, response)
|
|
663
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.CreateBusinessResponse>|undefined}
|
|
664
|
+
* The XHR Node Readable Stream
|
|
665
|
+
*/
|
|
666
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.createBusiness =
|
|
667
|
+
function(request, metadata, callback) {
|
|
668
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
669
|
+
'/payrollserviceapi.PayrollService/CreateBusiness',
|
|
670
|
+
request,
|
|
671
|
+
metadata || {},
|
|
672
|
+
methodDescriptor_PayrollService_CreateBusiness,
|
|
673
|
+
callback);
|
|
674
|
+
};
|
|
675
|
+
|
|
676
|
+
|
|
677
|
+
/**
|
|
678
|
+
* @param {!proto.payrollserviceapi.CreateBusinessRequest} request The
|
|
679
|
+
* request proto
|
|
680
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
681
|
+
* call metadata
|
|
682
|
+
* @return {!Promise<!proto.payrollserviceapi.CreateBusinessResponse>}
|
|
683
|
+
* Promise that resolves to the response
|
|
684
|
+
*/
|
|
685
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.createBusiness =
|
|
686
|
+
function(request, metadata) {
|
|
687
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
688
|
+
'/payrollserviceapi.PayrollService/CreateBusiness',
|
|
689
|
+
request,
|
|
690
|
+
metadata || {},
|
|
691
|
+
methodDescriptor_PayrollService_CreateBusiness);
|
|
692
|
+
};
|
|
693
|
+
|
|
694
|
+
|
|
695
|
+
/**
|
|
696
|
+
* @const
|
|
697
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
698
|
+
* !proto.payrollserviceapi.ListBusinessesRequest,
|
|
699
|
+
* !proto.payrollserviceapi.ListBusinessesResponse>}
|
|
700
|
+
*/
|
|
701
|
+
const methodDescriptor_PayrollService_ListBusinesses = new grpc.web.MethodDescriptor(
|
|
702
|
+
'/payrollserviceapi.PayrollService/ListBusinesses',
|
|
703
|
+
grpc.web.MethodType.UNARY,
|
|
704
|
+
proto.payrollserviceapi.ListBusinessesRequest,
|
|
705
|
+
proto.payrollserviceapi.ListBusinessesResponse,
|
|
706
|
+
/**
|
|
707
|
+
* @param {!proto.payrollserviceapi.ListBusinessesRequest} request
|
|
708
|
+
* @return {!Uint8Array}
|
|
709
|
+
*/
|
|
710
|
+
function(request) {
|
|
711
|
+
return request.serializeBinary();
|
|
712
|
+
},
|
|
713
|
+
proto.payrollserviceapi.ListBusinessesResponse.deserializeBinary
|
|
714
|
+
);
|
|
715
|
+
|
|
716
|
+
|
|
717
|
+
/**
|
|
718
|
+
* @param {!proto.payrollserviceapi.ListBusinessesRequest} request The
|
|
719
|
+
* request proto
|
|
720
|
+
* @param {?Object<string, string>} metadata User defined
|
|
721
|
+
* call metadata
|
|
722
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.ListBusinessesResponse)}
|
|
723
|
+
* callback The callback function(error, response)
|
|
724
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.ListBusinessesResponse>|undefined}
|
|
725
|
+
* The XHR Node Readable Stream
|
|
726
|
+
*/
|
|
727
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.listBusinesses =
|
|
728
|
+
function(request, metadata, callback) {
|
|
729
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
730
|
+
'/payrollserviceapi.PayrollService/ListBusinesses',
|
|
731
|
+
request,
|
|
732
|
+
metadata || {},
|
|
733
|
+
methodDescriptor_PayrollService_ListBusinesses,
|
|
734
|
+
callback);
|
|
735
|
+
};
|
|
736
|
+
|
|
737
|
+
|
|
738
|
+
/**
|
|
739
|
+
* @param {!proto.payrollserviceapi.ListBusinessesRequest} request The
|
|
740
|
+
* request proto
|
|
741
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
742
|
+
* call metadata
|
|
743
|
+
* @return {!Promise<!proto.payrollserviceapi.ListBusinessesResponse>}
|
|
744
|
+
* Promise that resolves to the response
|
|
745
|
+
*/
|
|
746
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.listBusinesses =
|
|
747
|
+
function(request, metadata) {
|
|
748
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
749
|
+
'/payrollserviceapi.PayrollService/ListBusinesses',
|
|
750
|
+
request,
|
|
751
|
+
metadata || {},
|
|
752
|
+
methodDescriptor_PayrollService_ListBusinesses);
|
|
753
|
+
};
|
|
754
|
+
|
|
755
|
+
|
|
756
|
+
/**
|
|
757
|
+
* @const
|
|
758
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
759
|
+
* !proto.payrollserviceapi.GetBusinessRequest,
|
|
760
|
+
* !proto.payrollserviceapi.GetBusinessResponse>}
|
|
761
|
+
*/
|
|
762
|
+
const methodDescriptor_PayrollService_GetBusiness = new grpc.web.MethodDescriptor(
|
|
763
|
+
'/payrollserviceapi.PayrollService/GetBusiness',
|
|
764
|
+
grpc.web.MethodType.UNARY,
|
|
765
|
+
proto.payrollserviceapi.GetBusinessRequest,
|
|
766
|
+
proto.payrollserviceapi.GetBusinessResponse,
|
|
767
|
+
/**
|
|
768
|
+
* @param {!proto.payrollserviceapi.GetBusinessRequest} request
|
|
769
|
+
* @return {!Uint8Array}
|
|
770
|
+
*/
|
|
771
|
+
function(request) {
|
|
772
|
+
return request.serializeBinary();
|
|
773
|
+
},
|
|
774
|
+
proto.payrollserviceapi.GetBusinessResponse.deserializeBinary
|
|
775
|
+
);
|
|
776
|
+
|
|
777
|
+
|
|
778
|
+
/**
|
|
779
|
+
* @param {!proto.payrollserviceapi.GetBusinessRequest} request The
|
|
780
|
+
* request proto
|
|
781
|
+
* @param {?Object<string, string>} metadata User defined
|
|
782
|
+
* call metadata
|
|
783
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.GetBusinessResponse)}
|
|
784
|
+
* callback The callback function(error, response)
|
|
785
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.GetBusinessResponse>|undefined}
|
|
786
|
+
* The XHR Node Readable Stream
|
|
787
|
+
*/
|
|
788
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.getBusiness =
|
|
789
|
+
function(request, metadata, callback) {
|
|
790
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
791
|
+
'/payrollserviceapi.PayrollService/GetBusiness',
|
|
792
|
+
request,
|
|
793
|
+
metadata || {},
|
|
794
|
+
methodDescriptor_PayrollService_GetBusiness,
|
|
795
|
+
callback);
|
|
796
|
+
};
|
|
797
|
+
|
|
798
|
+
|
|
799
|
+
/**
|
|
800
|
+
* @param {!proto.payrollserviceapi.GetBusinessRequest} request The
|
|
801
|
+
* request proto
|
|
802
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
803
|
+
* call metadata
|
|
804
|
+
* @return {!Promise<!proto.payrollserviceapi.GetBusinessResponse>}
|
|
805
|
+
* Promise that resolves to the response
|
|
806
|
+
*/
|
|
807
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.getBusiness =
|
|
808
|
+
function(request, metadata) {
|
|
809
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
810
|
+
'/payrollserviceapi.PayrollService/GetBusiness',
|
|
811
|
+
request,
|
|
812
|
+
metadata || {},
|
|
813
|
+
methodDescriptor_PayrollService_GetBusiness);
|
|
814
|
+
};
|
|
815
|
+
|
|
816
|
+
|
|
817
|
+
/**
|
|
818
|
+
* @const
|
|
819
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
820
|
+
* !proto.payrollserviceapi.UpdateBusinessRequest,
|
|
821
|
+
* !proto.payrollserviceapi.UpdateBusinessResponse>}
|
|
822
|
+
*/
|
|
823
|
+
const methodDescriptor_PayrollService_UpdateBusiness = new grpc.web.MethodDescriptor(
|
|
824
|
+
'/payrollserviceapi.PayrollService/UpdateBusiness',
|
|
825
|
+
grpc.web.MethodType.UNARY,
|
|
826
|
+
proto.payrollserviceapi.UpdateBusinessRequest,
|
|
827
|
+
proto.payrollserviceapi.UpdateBusinessResponse,
|
|
828
|
+
/**
|
|
829
|
+
* @param {!proto.payrollserviceapi.UpdateBusinessRequest} request
|
|
830
|
+
* @return {!Uint8Array}
|
|
831
|
+
*/
|
|
832
|
+
function(request) {
|
|
833
|
+
return request.serializeBinary();
|
|
834
|
+
},
|
|
835
|
+
proto.payrollserviceapi.UpdateBusinessResponse.deserializeBinary
|
|
836
|
+
);
|
|
837
|
+
|
|
838
|
+
|
|
839
|
+
/**
|
|
840
|
+
* @param {!proto.payrollserviceapi.UpdateBusinessRequest} request The
|
|
841
|
+
* request proto
|
|
842
|
+
* @param {?Object<string, string>} metadata User defined
|
|
843
|
+
* call metadata
|
|
844
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.UpdateBusinessResponse)}
|
|
845
|
+
* callback The callback function(error, response)
|
|
846
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.UpdateBusinessResponse>|undefined}
|
|
847
|
+
* The XHR Node Readable Stream
|
|
848
|
+
*/
|
|
849
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.updateBusiness =
|
|
850
|
+
function(request, metadata, callback) {
|
|
851
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
852
|
+
'/payrollserviceapi.PayrollService/UpdateBusiness',
|
|
853
|
+
request,
|
|
854
|
+
metadata || {},
|
|
855
|
+
methodDescriptor_PayrollService_UpdateBusiness,
|
|
856
|
+
callback);
|
|
857
|
+
};
|
|
858
|
+
|
|
859
|
+
|
|
860
|
+
/**
|
|
861
|
+
* @param {!proto.payrollserviceapi.UpdateBusinessRequest} request The
|
|
862
|
+
* request proto
|
|
863
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
864
|
+
* call metadata
|
|
865
|
+
* @return {!Promise<!proto.payrollserviceapi.UpdateBusinessResponse>}
|
|
866
|
+
* Promise that resolves to the response
|
|
867
|
+
*/
|
|
868
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.updateBusiness =
|
|
869
|
+
function(request, metadata) {
|
|
870
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
871
|
+
'/payrollserviceapi.PayrollService/UpdateBusiness',
|
|
872
|
+
request,
|
|
873
|
+
metadata || {},
|
|
874
|
+
methodDescriptor_PayrollService_UpdateBusiness);
|
|
875
|
+
};
|
|
876
|
+
|
|
877
|
+
|
|
878
|
+
/**
|
|
879
|
+
* @const
|
|
880
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
881
|
+
* !proto.payrollserviceapi.DeleteBusinessRequest,
|
|
882
|
+
* !proto.payrollserviceapi.DeleteBusinessResponse>}
|
|
883
|
+
*/
|
|
884
|
+
const methodDescriptor_PayrollService_DeleteBusiness = new grpc.web.MethodDescriptor(
|
|
885
|
+
'/payrollserviceapi.PayrollService/DeleteBusiness',
|
|
886
|
+
grpc.web.MethodType.UNARY,
|
|
887
|
+
proto.payrollserviceapi.DeleteBusinessRequest,
|
|
888
|
+
proto.payrollserviceapi.DeleteBusinessResponse,
|
|
889
|
+
/**
|
|
890
|
+
* @param {!proto.payrollserviceapi.DeleteBusinessRequest} request
|
|
891
|
+
* @return {!Uint8Array}
|
|
892
|
+
*/
|
|
893
|
+
function(request) {
|
|
894
|
+
return request.serializeBinary();
|
|
895
|
+
},
|
|
896
|
+
proto.payrollserviceapi.DeleteBusinessResponse.deserializeBinary
|
|
897
|
+
);
|
|
898
|
+
|
|
899
|
+
|
|
900
|
+
/**
|
|
901
|
+
* @param {!proto.payrollserviceapi.DeleteBusinessRequest} request The
|
|
902
|
+
* request proto
|
|
903
|
+
* @param {?Object<string, string>} metadata User defined
|
|
904
|
+
* call metadata
|
|
905
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.DeleteBusinessResponse)}
|
|
906
|
+
* callback The callback function(error, response)
|
|
907
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.DeleteBusinessResponse>|undefined}
|
|
908
|
+
* The XHR Node Readable Stream
|
|
909
|
+
*/
|
|
910
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.deleteBusiness =
|
|
911
|
+
function(request, metadata, callback) {
|
|
912
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
913
|
+
'/payrollserviceapi.PayrollService/DeleteBusiness',
|
|
914
|
+
request,
|
|
915
|
+
metadata || {},
|
|
916
|
+
methodDescriptor_PayrollService_DeleteBusiness,
|
|
917
|
+
callback);
|
|
918
|
+
};
|
|
919
|
+
|
|
920
|
+
|
|
921
|
+
/**
|
|
922
|
+
* @param {!proto.payrollserviceapi.DeleteBusinessRequest} request The
|
|
923
|
+
* request proto
|
|
924
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
925
|
+
* call metadata
|
|
926
|
+
* @return {!Promise<!proto.payrollserviceapi.DeleteBusinessResponse>}
|
|
927
|
+
* Promise that resolves to the response
|
|
928
|
+
*/
|
|
929
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.deleteBusiness =
|
|
930
|
+
function(request, metadata) {
|
|
931
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
932
|
+
'/payrollserviceapi.PayrollService/DeleteBusiness',
|
|
933
|
+
request,
|
|
934
|
+
metadata || {},
|
|
935
|
+
methodDescriptor_PayrollService_DeleteBusiness);
|
|
936
|
+
};
|
|
937
|
+
|
|
938
|
+
|
|
939
|
+
/**
|
|
940
|
+
* @const
|
|
941
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
942
|
+
* !proto.payrollserviceapi.CreateEmployeeRequest,
|
|
943
|
+
* !proto.payrollserviceapi.CreateEmployeeResponse>}
|
|
944
|
+
*/
|
|
945
|
+
const methodDescriptor_PayrollService_CreateEmployee = new grpc.web.MethodDescriptor(
|
|
946
|
+
'/payrollserviceapi.PayrollService/CreateEmployee',
|
|
947
|
+
grpc.web.MethodType.UNARY,
|
|
948
|
+
proto.payrollserviceapi.CreateEmployeeRequest,
|
|
949
|
+
proto.payrollserviceapi.CreateEmployeeResponse,
|
|
950
|
+
/**
|
|
951
|
+
* @param {!proto.payrollserviceapi.CreateEmployeeRequest} request
|
|
952
|
+
* @return {!Uint8Array}
|
|
953
|
+
*/
|
|
954
|
+
function(request) {
|
|
955
|
+
return request.serializeBinary();
|
|
956
|
+
},
|
|
957
|
+
proto.payrollserviceapi.CreateEmployeeResponse.deserializeBinary
|
|
958
|
+
);
|
|
959
|
+
|
|
960
|
+
|
|
961
|
+
/**
|
|
962
|
+
* @param {!proto.payrollserviceapi.CreateEmployeeRequest} request The
|
|
963
|
+
* request proto
|
|
964
|
+
* @param {?Object<string, string>} metadata User defined
|
|
965
|
+
* call metadata
|
|
966
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.CreateEmployeeResponse)}
|
|
967
|
+
* callback The callback function(error, response)
|
|
968
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.CreateEmployeeResponse>|undefined}
|
|
969
|
+
* The XHR Node Readable Stream
|
|
970
|
+
*/
|
|
971
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.createEmployee =
|
|
972
|
+
function(request, metadata, callback) {
|
|
973
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
974
|
+
'/payrollserviceapi.PayrollService/CreateEmployee',
|
|
975
|
+
request,
|
|
976
|
+
metadata || {},
|
|
977
|
+
methodDescriptor_PayrollService_CreateEmployee,
|
|
978
|
+
callback);
|
|
979
|
+
};
|
|
980
|
+
|
|
981
|
+
|
|
982
|
+
/**
|
|
983
|
+
* @param {!proto.payrollserviceapi.CreateEmployeeRequest} request The
|
|
984
|
+
* request proto
|
|
985
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
986
|
+
* call metadata
|
|
987
|
+
* @return {!Promise<!proto.payrollserviceapi.CreateEmployeeResponse>}
|
|
988
|
+
* Promise that resolves to the response
|
|
989
|
+
*/
|
|
990
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.createEmployee =
|
|
991
|
+
function(request, metadata) {
|
|
992
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
993
|
+
'/payrollserviceapi.PayrollService/CreateEmployee',
|
|
994
|
+
request,
|
|
995
|
+
metadata || {},
|
|
996
|
+
methodDescriptor_PayrollService_CreateEmployee);
|
|
997
|
+
};
|
|
998
|
+
|
|
999
|
+
|
|
1000
|
+
/**
|
|
1001
|
+
* @const
|
|
1002
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
1003
|
+
* !proto.payrollserviceapi.ListEmployeesRequest,
|
|
1004
|
+
* !proto.payrollserviceapi.ListEmployeesResponse>}
|
|
1005
|
+
*/
|
|
1006
|
+
const methodDescriptor_PayrollService_ListEmployees = new grpc.web.MethodDescriptor(
|
|
1007
|
+
'/payrollserviceapi.PayrollService/ListEmployees',
|
|
1008
|
+
grpc.web.MethodType.UNARY,
|
|
1009
|
+
proto.payrollserviceapi.ListEmployeesRequest,
|
|
1010
|
+
proto.payrollserviceapi.ListEmployeesResponse,
|
|
1011
|
+
/**
|
|
1012
|
+
* @param {!proto.payrollserviceapi.ListEmployeesRequest} request
|
|
1013
|
+
* @return {!Uint8Array}
|
|
1014
|
+
*/
|
|
1015
|
+
function(request) {
|
|
1016
|
+
return request.serializeBinary();
|
|
1017
|
+
},
|
|
1018
|
+
proto.payrollserviceapi.ListEmployeesResponse.deserializeBinary
|
|
1019
|
+
);
|
|
1020
|
+
|
|
1021
|
+
|
|
1022
|
+
/**
|
|
1023
|
+
* @param {!proto.payrollserviceapi.ListEmployeesRequest} request The
|
|
1024
|
+
* request proto
|
|
1025
|
+
* @param {?Object<string, string>} metadata User defined
|
|
1026
|
+
* call metadata
|
|
1027
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.ListEmployeesResponse)}
|
|
1028
|
+
* callback The callback function(error, response)
|
|
1029
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.ListEmployeesResponse>|undefined}
|
|
1030
|
+
* The XHR Node Readable Stream
|
|
1031
|
+
*/
|
|
1032
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.listEmployees =
|
|
1033
|
+
function(request, metadata, callback) {
|
|
1034
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
1035
|
+
'/payrollserviceapi.PayrollService/ListEmployees',
|
|
1036
|
+
request,
|
|
1037
|
+
metadata || {},
|
|
1038
|
+
methodDescriptor_PayrollService_ListEmployees,
|
|
1039
|
+
callback);
|
|
1040
|
+
};
|
|
1041
|
+
|
|
1042
|
+
|
|
1043
|
+
/**
|
|
1044
|
+
* @param {!proto.payrollserviceapi.ListEmployeesRequest} request The
|
|
1045
|
+
* request proto
|
|
1046
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
1047
|
+
* call metadata
|
|
1048
|
+
* @return {!Promise<!proto.payrollserviceapi.ListEmployeesResponse>}
|
|
1049
|
+
* Promise that resolves to the response
|
|
1050
|
+
*/
|
|
1051
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.listEmployees =
|
|
1052
|
+
function(request, metadata) {
|
|
1053
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
1054
|
+
'/payrollserviceapi.PayrollService/ListEmployees',
|
|
1055
|
+
request,
|
|
1056
|
+
metadata || {},
|
|
1057
|
+
methodDescriptor_PayrollService_ListEmployees);
|
|
1058
|
+
};
|
|
1059
|
+
|
|
1060
|
+
|
|
1061
|
+
/**
|
|
1062
|
+
* @const
|
|
1063
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
1064
|
+
* !proto.payrollserviceapi.GetEmployeeRequest,
|
|
1065
|
+
* !proto.payrollserviceapi.GetEmployeeResponse>}
|
|
1066
|
+
*/
|
|
1067
|
+
const methodDescriptor_PayrollService_GetEmployee = new grpc.web.MethodDescriptor(
|
|
1068
|
+
'/payrollserviceapi.PayrollService/GetEmployee',
|
|
1069
|
+
grpc.web.MethodType.UNARY,
|
|
1070
|
+
proto.payrollserviceapi.GetEmployeeRequest,
|
|
1071
|
+
proto.payrollserviceapi.GetEmployeeResponse,
|
|
1072
|
+
/**
|
|
1073
|
+
* @param {!proto.payrollserviceapi.GetEmployeeRequest} request
|
|
1074
|
+
* @return {!Uint8Array}
|
|
1075
|
+
*/
|
|
1076
|
+
function(request) {
|
|
1077
|
+
return request.serializeBinary();
|
|
1078
|
+
},
|
|
1079
|
+
proto.payrollserviceapi.GetEmployeeResponse.deserializeBinary
|
|
1080
|
+
);
|
|
1081
|
+
|
|
1082
|
+
|
|
1083
|
+
/**
|
|
1084
|
+
* @param {!proto.payrollserviceapi.GetEmployeeRequest} request The
|
|
1085
|
+
* request proto
|
|
1086
|
+
* @param {?Object<string, string>} metadata User defined
|
|
1087
|
+
* call metadata
|
|
1088
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.GetEmployeeResponse)}
|
|
1089
|
+
* callback The callback function(error, response)
|
|
1090
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.GetEmployeeResponse>|undefined}
|
|
1091
|
+
* The XHR Node Readable Stream
|
|
1092
|
+
*/
|
|
1093
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.getEmployee =
|
|
1094
|
+
function(request, metadata, callback) {
|
|
1095
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
1096
|
+
'/payrollserviceapi.PayrollService/GetEmployee',
|
|
1097
|
+
request,
|
|
1098
|
+
metadata || {},
|
|
1099
|
+
methodDescriptor_PayrollService_GetEmployee,
|
|
1100
|
+
callback);
|
|
1101
|
+
};
|
|
1102
|
+
|
|
1103
|
+
|
|
1104
|
+
/**
|
|
1105
|
+
* @param {!proto.payrollserviceapi.GetEmployeeRequest} request The
|
|
1106
|
+
* request proto
|
|
1107
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
1108
|
+
* call metadata
|
|
1109
|
+
* @return {!Promise<!proto.payrollserviceapi.GetEmployeeResponse>}
|
|
1110
|
+
* Promise that resolves to the response
|
|
1111
|
+
*/
|
|
1112
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.getEmployee =
|
|
1113
|
+
function(request, metadata) {
|
|
1114
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
1115
|
+
'/payrollserviceapi.PayrollService/GetEmployee',
|
|
1116
|
+
request,
|
|
1117
|
+
metadata || {},
|
|
1118
|
+
methodDescriptor_PayrollService_GetEmployee);
|
|
1119
|
+
};
|
|
1120
|
+
|
|
1121
|
+
|
|
1122
|
+
/**
|
|
1123
|
+
* @const
|
|
1124
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
1125
|
+
* !proto.payrollserviceapi.UpdateEmployeeRequest,
|
|
1126
|
+
* !proto.payrollserviceapi.UpdateEmployeeResponse>}
|
|
1127
|
+
*/
|
|
1128
|
+
const methodDescriptor_PayrollService_UpdateEmployee = new grpc.web.MethodDescriptor(
|
|
1129
|
+
'/payrollserviceapi.PayrollService/UpdateEmployee',
|
|
1130
|
+
grpc.web.MethodType.UNARY,
|
|
1131
|
+
proto.payrollserviceapi.UpdateEmployeeRequest,
|
|
1132
|
+
proto.payrollserviceapi.UpdateEmployeeResponse,
|
|
1133
|
+
/**
|
|
1134
|
+
* @param {!proto.payrollserviceapi.UpdateEmployeeRequest} request
|
|
1135
|
+
* @return {!Uint8Array}
|
|
1136
|
+
*/
|
|
1137
|
+
function(request) {
|
|
1138
|
+
return request.serializeBinary();
|
|
1139
|
+
},
|
|
1140
|
+
proto.payrollserviceapi.UpdateEmployeeResponse.deserializeBinary
|
|
1141
|
+
);
|
|
1142
|
+
|
|
1143
|
+
|
|
1144
|
+
/**
|
|
1145
|
+
* @param {!proto.payrollserviceapi.UpdateEmployeeRequest} request The
|
|
1146
|
+
* request proto
|
|
1147
|
+
* @param {?Object<string, string>} metadata User defined
|
|
1148
|
+
* call metadata
|
|
1149
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.UpdateEmployeeResponse)}
|
|
1150
|
+
* callback The callback function(error, response)
|
|
1151
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.UpdateEmployeeResponse>|undefined}
|
|
1152
|
+
* The XHR Node Readable Stream
|
|
1153
|
+
*/
|
|
1154
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.updateEmployee =
|
|
1155
|
+
function(request, metadata, callback) {
|
|
1156
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
1157
|
+
'/payrollserviceapi.PayrollService/UpdateEmployee',
|
|
1158
|
+
request,
|
|
1159
|
+
metadata || {},
|
|
1160
|
+
methodDescriptor_PayrollService_UpdateEmployee,
|
|
1161
|
+
callback);
|
|
1162
|
+
};
|
|
1163
|
+
|
|
1164
|
+
|
|
1165
|
+
/**
|
|
1166
|
+
* @param {!proto.payrollserviceapi.UpdateEmployeeRequest} request The
|
|
1167
|
+
* request proto
|
|
1168
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
1169
|
+
* call metadata
|
|
1170
|
+
* @return {!Promise<!proto.payrollserviceapi.UpdateEmployeeResponse>}
|
|
1171
|
+
* Promise that resolves to the response
|
|
1172
|
+
*/
|
|
1173
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.updateEmployee =
|
|
1174
|
+
function(request, metadata) {
|
|
1175
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
1176
|
+
'/payrollserviceapi.PayrollService/UpdateEmployee',
|
|
1177
|
+
request,
|
|
1178
|
+
metadata || {},
|
|
1179
|
+
methodDescriptor_PayrollService_UpdateEmployee);
|
|
1180
|
+
};
|
|
1181
|
+
|
|
1182
|
+
|
|
1183
|
+
/**
|
|
1184
|
+
* @const
|
|
1185
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
1186
|
+
* !proto.payrollserviceapi.DeleteEmployeeRequest,
|
|
1187
|
+
* !proto.payrollserviceapi.DeleteEmployeeResponse>}
|
|
1188
|
+
*/
|
|
1189
|
+
const methodDescriptor_PayrollService_DeleteEmployee = new grpc.web.MethodDescriptor(
|
|
1190
|
+
'/payrollserviceapi.PayrollService/DeleteEmployee',
|
|
1191
|
+
grpc.web.MethodType.UNARY,
|
|
1192
|
+
proto.payrollserviceapi.DeleteEmployeeRequest,
|
|
1193
|
+
proto.payrollserviceapi.DeleteEmployeeResponse,
|
|
1194
|
+
/**
|
|
1195
|
+
* @param {!proto.payrollserviceapi.DeleteEmployeeRequest} request
|
|
1196
|
+
* @return {!Uint8Array}
|
|
1197
|
+
*/
|
|
1198
|
+
function(request) {
|
|
1199
|
+
return request.serializeBinary();
|
|
1200
|
+
},
|
|
1201
|
+
proto.payrollserviceapi.DeleteEmployeeResponse.deserializeBinary
|
|
1202
|
+
);
|
|
1203
|
+
|
|
1204
|
+
|
|
1205
|
+
/**
|
|
1206
|
+
* @param {!proto.payrollserviceapi.DeleteEmployeeRequest} request The
|
|
1207
|
+
* request proto
|
|
1208
|
+
* @param {?Object<string, string>} metadata User defined
|
|
1209
|
+
* call metadata
|
|
1210
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.DeleteEmployeeResponse)}
|
|
1211
|
+
* callback The callback function(error, response)
|
|
1212
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.DeleteEmployeeResponse>|undefined}
|
|
1213
|
+
* The XHR Node Readable Stream
|
|
1214
|
+
*/
|
|
1215
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.deleteEmployee =
|
|
1216
|
+
function(request, metadata, callback) {
|
|
1217
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
1218
|
+
'/payrollserviceapi.PayrollService/DeleteEmployee',
|
|
1219
|
+
request,
|
|
1220
|
+
metadata || {},
|
|
1221
|
+
methodDescriptor_PayrollService_DeleteEmployee,
|
|
1222
|
+
callback);
|
|
1223
|
+
};
|
|
1224
|
+
|
|
1225
|
+
|
|
1226
|
+
/**
|
|
1227
|
+
* @param {!proto.payrollserviceapi.DeleteEmployeeRequest} request The
|
|
1228
|
+
* request proto
|
|
1229
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
1230
|
+
* call metadata
|
|
1231
|
+
* @return {!Promise<!proto.payrollserviceapi.DeleteEmployeeResponse>}
|
|
1232
|
+
* Promise that resolves to the response
|
|
1233
|
+
*/
|
|
1234
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.deleteEmployee =
|
|
1235
|
+
function(request, metadata) {
|
|
1236
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
1237
|
+
'/payrollserviceapi.PayrollService/DeleteEmployee',
|
|
1238
|
+
request,
|
|
1239
|
+
metadata || {},
|
|
1240
|
+
methodDescriptor_PayrollService_DeleteEmployee);
|
|
1241
|
+
};
|
|
1242
|
+
|
|
1243
|
+
|
|
1244
|
+
/**
|
|
1245
|
+
* @const
|
|
1246
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
1247
|
+
* !proto.payrollserviceapi.BulkImportEmployeesRequest,
|
|
1248
|
+
* !proto.payrollserviceapi.BulkImportEmployeesResponse>}
|
|
1249
|
+
*/
|
|
1250
|
+
const methodDescriptor_PayrollService_BulkImportEmployees = new grpc.web.MethodDescriptor(
|
|
1251
|
+
'/payrollserviceapi.PayrollService/BulkImportEmployees',
|
|
1252
|
+
grpc.web.MethodType.UNARY,
|
|
1253
|
+
proto.payrollserviceapi.BulkImportEmployeesRequest,
|
|
1254
|
+
proto.payrollserviceapi.BulkImportEmployeesResponse,
|
|
1255
|
+
/**
|
|
1256
|
+
* @param {!proto.payrollserviceapi.BulkImportEmployeesRequest} request
|
|
1257
|
+
* @return {!Uint8Array}
|
|
1258
|
+
*/
|
|
1259
|
+
function(request) {
|
|
1260
|
+
return request.serializeBinary();
|
|
1261
|
+
},
|
|
1262
|
+
proto.payrollserviceapi.BulkImportEmployeesResponse.deserializeBinary
|
|
1263
|
+
);
|
|
1264
|
+
|
|
1265
|
+
|
|
1266
|
+
/**
|
|
1267
|
+
* @param {!proto.payrollserviceapi.BulkImportEmployeesRequest} request The
|
|
1268
|
+
* request proto
|
|
1269
|
+
* @param {?Object<string, string>} metadata User defined
|
|
1270
|
+
* call metadata
|
|
1271
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.BulkImportEmployeesResponse)}
|
|
1272
|
+
* callback The callback function(error, response)
|
|
1273
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.BulkImportEmployeesResponse>|undefined}
|
|
1274
|
+
* The XHR Node Readable Stream
|
|
1275
|
+
*/
|
|
1276
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.bulkImportEmployees =
|
|
1277
|
+
function(request, metadata, callback) {
|
|
1278
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
1279
|
+
'/payrollserviceapi.PayrollService/BulkImportEmployees',
|
|
1280
|
+
request,
|
|
1281
|
+
metadata || {},
|
|
1282
|
+
methodDescriptor_PayrollService_BulkImportEmployees,
|
|
1283
|
+
callback);
|
|
1284
|
+
};
|
|
1285
|
+
|
|
1286
|
+
|
|
1287
|
+
/**
|
|
1288
|
+
* @param {!proto.payrollserviceapi.BulkImportEmployeesRequest} request The
|
|
1289
|
+
* request proto
|
|
1290
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
1291
|
+
* call metadata
|
|
1292
|
+
* @return {!Promise<!proto.payrollserviceapi.BulkImportEmployeesResponse>}
|
|
1293
|
+
* Promise that resolves to the response
|
|
1294
|
+
*/
|
|
1295
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.bulkImportEmployees =
|
|
1296
|
+
function(request, metadata) {
|
|
1297
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
1298
|
+
'/payrollserviceapi.PayrollService/BulkImportEmployees',
|
|
1299
|
+
request,
|
|
1300
|
+
metadata || {},
|
|
1301
|
+
methodDescriptor_PayrollService_BulkImportEmployees);
|
|
1302
|
+
};
|
|
1303
|
+
|
|
1304
|
+
|
|
1305
|
+
/**
|
|
1306
|
+
* @const
|
|
1307
|
+
* @type {!grpc.web.MethodDescriptor<
|
|
1308
|
+
* !proto.payrollserviceapi.GetUserProfileRequest,
|
|
1309
|
+
* !proto.payrollserviceapi.GetUserProfileResponse>}
|
|
1310
|
+
*/
|
|
1311
|
+
const methodDescriptor_PayrollService_GetUserProfile = new grpc.web.MethodDescriptor(
|
|
1312
|
+
'/payrollserviceapi.PayrollService/GetUserProfile',
|
|
1313
|
+
grpc.web.MethodType.UNARY,
|
|
1314
|
+
proto.payrollserviceapi.GetUserProfileRequest,
|
|
1315
|
+
proto.payrollserviceapi.GetUserProfileResponse,
|
|
1316
|
+
/**
|
|
1317
|
+
* @param {!proto.payrollserviceapi.GetUserProfileRequest} request
|
|
1318
|
+
* @return {!Uint8Array}
|
|
1319
|
+
*/
|
|
1320
|
+
function(request) {
|
|
1321
|
+
return request.serializeBinary();
|
|
1322
|
+
},
|
|
1323
|
+
proto.payrollserviceapi.GetUserProfileResponse.deserializeBinary
|
|
1324
|
+
);
|
|
1325
|
+
|
|
1326
|
+
|
|
1327
|
+
/**
|
|
1328
|
+
* @param {!proto.payrollserviceapi.GetUserProfileRequest} request The
|
|
1329
|
+
* request proto
|
|
1330
|
+
* @param {?Object<string, string>} metadata User defined
|
|
1331
|
+
* call metadata
|
|
1332
|
+
* @param {function(?grpc.web.RpcError, ?proto.payrollserviceapi.GetUserProfileResponse)}
|
|
1333
|
+
* callback The callback function(error, response)
|
|
1334
|
+
* @return {!grpc.web.ClientReadableStream<!proto.payrollserviceapi.GetUserProfileResponse>|undefined}
|
|
1335
|
+
* The XHR Node Readable Stream
|
|
1336
|
+
*/
|
|
1337
|
+
proto.payrollserviceapi.PayrollServiceClient.prototype.getUserProfile =
|
|
1338
|
+
function(request, metadata, callback) {
|
|
1339
|
+
return this.client_.rpcCall(this.hostname_ +
|
|
1340
|
+
'/payrollserviceapi.PayrollService/GetUserProfile',
|
|
1341
|
+
request,
|
|
1342
|
+
metadata || {},
|
|
1343
|
+
methodDescriptor_PayrollService_GetUserProfile,
|
|
1344
|
+
callback);
|
|
1345
|
+
};
|
|
1346
|
+
|
|
1347
|
+
|
|
1348
|
+
/**
|
|
1349
|
+
* @param {!proto.payrollserviceapi.GetUserProfileRequest} request The
|
|
1350
|
+
* request proto
|
|
1351
|
+
* @param {?Object<string, string>=} metadata User defined
|
|
1352
|
+
* call metadata
|
|
1353
|
+
* @return {!Promise<!proto.payrollserviceapi.GetUserProfileResponse>}
|
|
1354
|
+
* Promise that resolves to the response
|
|
1355
|
+
*/
|
|
1356
|
+
proto.payrollserviceapi.PayrollServicePromiseClient.prototype.getUserProfile =
|
|
1357
|
+
function(request, metadata) {
|
|
1358
|
+
return this.client_.unaryCall(this.hostname_ +
|
|
1359
|
+
'/payrollserviceapi.PayrollService/GetUserProfile',
|
|
1360
|
+
request,
|
|
1361
|
+
metadata || {},
|
|
1362
|
+
methodDescriptor_PayrollService_GetUserProfile);
|
|
1363
|
+
};
|
|
1364
|
+
|
|
1365
|
+
|
|
1366
|
+
module.exports = proto.payrollserviceapi;
|
|
208
1367
|
|