@sniipwebmaster/payroll-service-client-grpcweb 25.7.29 → 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 +1159 -0
- package/dependancies/service_pb.js +14947 -42
- package/package.json +1 -1
|
@@ -204,5 +204,1164 @@ proto.payrollserviceapi.PayrollServicePromiseClient.prototype.localHealth =
|
|
|
204
204
|
};
|
|
205
205
|
|
|
206
206
|
|
|
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
|
+
|
|
207
1366
|
module.exports = proto.payrollserviceapi;
|
|
208
1367
|
|