@aws-sdk/client-transcribe 3.503.1 → 3.507.0

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.
Files changed (3) hide show
  1. package/dist-cjs/index.js +71 -1217
  2. package/dist-es/protocols/Aws_json1_1.js +111 -1257
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -262,7 +262,7 @@ export const se_UpdateVocabularyFilterCommand = async (input, context) => {
262
262
  };
263
263
  export const de_CreateCallAnalyticsCategoryCommand = async (output, context) => {
264
264
  if (output.statusCode >= 300) {
265
- return de_CreateCallAnalyticsCategoryCommandError(output, context);
265
+ return de_CommandError(output, context);
266
266
  }
267
267
  const data = await parseBody(output.body, context);
268
268
  let contents = {};
@@ -273,37 +273,9 @@ export const de_CreateCallAnalyticsCategoryCommand = async (output, context) =>
273
273
  };
274
274
  return response;
275
275
  };
276
- const de_CreateCallAnalyticsCategoryCommandError = async (output, context) => {
277
- const parsedOutput = {
278
- ...output,
279
- body: await parseErrorBody(output.body, context),
280
- };
281
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
282
- switch (errorCode) {
283
- case "BadRequestException":
284
- case "com.amazonaws.transcribe#BadRequestException":
285
- throw await de_BadRequestExceptionRes(parsedOutput, context);
286
- case "ConflictException":
287
- case "com.amazonaws.transcribe#ConflictException":
288
- throw await de_ConflictExceptionRes(parsedOutput, context);
289
- case "InternalFailureException":
290
- case "com.amazonaws.transcribe#InternalFailureException":
291
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
292
- case "LimitExceededException":
293
- case "com.amazonaws.transcribe#LimitExceededException":
294
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
295
- default:
296
- const parsedBody = parsedOutput.body;
297
- return throwDefaultError({
298
- output,
299
- parsedBody,
300
- errorCode,
301
- });
302
- }
303
- };
304
276
  export const de_CreateLanguageModelCommand = async (output, context) => {
305
277
  if (output.statusCode >= 300) {
306
- return de_CreateLanguageModelCommandError(output, context);
278
+ return de_CommandError(output, context);
307
279
  }
308
280
  const data = await parseBody(output.body, context);
309
281
  let contents = {};
@@ -314,37 +286,9 @@ export const de_CreateLanguageModelCommand = async (output, context) => {
314
286
  };
315
287
  return response;
316
288
  };
317
- const de_CreateLanguageModelCommandError = async (output, context) => {
318
- const parsedOutput = {
319
- ...output,
320
- body: await parseErrorBody(output.body, context),
321
- };
322
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
323
- switch (errorCode) {
324
- case "BadRequestException":
325
- case "com.amazonaws.transcribe#BadRequestException":
326
- throw await de_BadRequestExceptionRes(parsedOutput, context);
327
- case "ConflictException":
328
- case "com.amazonaws.transcribe#ConflictException":
329
- throw await de_ConflictExceptionRes(parsedOutput, context);
330
- case "InternalFailureException":
331
- case "com.amazonaws.transcribe#InternalFailureException":
332
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
333
- case "LimitExceededException":
334
- case "com.amazonaws.transcribe#LimitExceededException":
335
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
336
- default:
337
- const parsedBody = parsedOutput.body;
338
- return throwDefaultError({
339
- output,
340
- parsedBody,
341
- errorCode,
342
- });
343
- }
344
- };
345
289
  export const de_CreateMedicalVocabularyCommand = async (output, context) => {
346
290
  if (output.statusCode >= 300) {
347
- return de_CreateMedicalVocabularyCommandError(output, context);
291
+ return de_CommandError(output, context);
348
292
  }
349
293
  const data = await parseBody(output.body, context);
350
294
  let contents = {};
@@ -355,37 +299,9 @@ export const de_CreateMedicalVocabularyCommand = async (output, context) => {
355
299
  };
356
300
  return response;
357
301
  };
358
- const de_CreateMedicalVocabularyCommandError = async (output, context) => {
359
- const parsedOutput = {
360
- ...output,
361
- body: await parseErrorBody(output.body, context),
362
- };
363
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
364
- switch (errorCode) {
365
- case "BadRequestException":
366
- case "com.amazonaws.transcribe#BadRequestException":
367
- throw await de_BadRequestExceptionRes(parsedOutput, context);
368
- case "ConflictException":
369
- case "com.amazonaws.transcribe#ConflictException":
370
- throw await de_ConflictExceptionRes(parsedOutput, context);
371
- case "InternalFailureException":
372
- case "com.amazonaws.transcribe#InternalFailureException":
373
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
374
- case "LimitExceededException":
375
- case "com.amazonaws.transcribe#LimitExceededException":
376
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
377
- default:
378
- const parsedBody = parsedOutput.body;
379
- return throwDefaultError({
380
- output,
381
- parsedBody,
382
- errorCode,
383
- });
384
- }
385
- };
386
302
  export const de_CreateVocabularyCommand = async (output, context) => {
387
303
  if (output.statusCode >= 300) {
388
- return de_CreateVocabularyCommandError(output, context);
304
+ return de_CommandError(output, context);
389
305
  }
390
306
  const data = await parseBody(output.body, context);
391
307
  let contents = {};
@@ -396,37 +312,9 @@ export const de_CreateVocabularyCommand = async (output, context) => {
396
312
  };
397
313
  return response;
398
314
  };
399
- const de_CreateVocabularyCommandError = async (output, context) => {
400
- const parsedOutput = {
401
- ...output,
402
- body: await parseErrorBody(output.body, context),
403
- };
404
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
405
- switch (errorCode) {
406
- case "BadRequestException":
407
- case "com.amazonaws.transcribe#BadRequestException":
408
- throw await de_BadRequestExceptionRes(parsedOutput, context);
409
- case "ConflictException":
410
- case "com.amazonaws.transcribe#ConflictException":
411
- throw await de_ConflictExceptionRes(parsedOutput, context);
412
- case "InternalFailureException":
413
- case "com.amazonaws.transcribe#InternalFailureException":
414
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
415
- case "LimitExceededException":
416
- case "com.amazonaws.transcribe#LimitExceededException":
417
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
418
- default:
419
- const parsedBody = parsedOutput.body;
420
- return throwDefaultError({
421
- output,
422
- parsedBody,
423
- errorCode,
424
- });
425
- }
426
- };
427
315
  export const de_CreateVocabularyFilterCommand = async (output, context) => {
428
316
  if (output.statusCode >= 300) {
429
- return de_CreateVocabularyFilterCommandError(output, context);
317
+ return de_CommandError(output, context);
430
318
  }
431
319
  const data = await parseBody(output.body, context);
432
320
  let contents = {};
@@ -437,37 +325,9 @@ export const de_CreateVocabularyFilterCommand = async (output, context) => {
437
325
  };
438
326
  return response;
439
327
  };
440
- const de_CreateVocabularyFilterCommandError = async (output, context) => {
441
- const parsedOutput = {
442
- ...output,
443
- body: await parseErrorBody(output.body, context),
444
- };
445
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
446
- switch (errorCode) {
447
- case "BadRequestException":
448
- case "com.amazonaws.transcribe#BadRequestException":
449
- throw await de_BadRequestExceptionRes(parsedOutput, context);
450
- case "ConflictException":
451
- case "com.amazonaws.transcribe#ConflictException":
452
- throw await de_ConflictExceptionRes(parsedOutput, context);
453
- case "InternalFailureException":
454
- case "com.amazonaws.transcribe#InternalFailureException":
455
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
456
- case "LimitExceededException":
457
- case "com.amazonaws.transcribe#LimitExceededException":
458
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
459
- default:
460
- const parsedBody = parsedOutput.body;
461
- return throwDefaultError({
462
- output,
463
- parsedBody,
464
- errorCode,
465
- });
466
- }
467
- };
468
328
  export const de_DeleteCallAnalyticsCategoryCommand = async (output, context) => {
469
329
  if (output.statusCode >= 300) {
470
- return de_DeleteCallAnalyticsCategoryCommandError(output, context);
330
+ return de_CommandError(output, context);
471
331
  }
472
332
  const data = await parseBody(output.body, context);
473
333
  let contents = {};
@@ -478,37 +338,9 @@ export const de_DeleteCallAnalyticsCategoryCommand = async (output, context) =>
478
338
  };
479
339
  return response;
480
340
  };
481
- const de_DeleteCallAnalyticsCategoryCommandError = async (output, context) => {
482
- const parsedOutput = {
483
- ...output,
484
- body: await parseErrorBody(output.body, context),
485
- };
486
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
487
- switch (errorCode) {
488
- case "BadRequestException":
489
- case "com.amazonaws.transcribe#BadRequestException":
490
- throw await de_BadRequestExceptionRes(parsedOutput, context);
491
- case "InternalFailureException":
492
- case "com.amazonaws.transcribe#InternalFailureException":
493
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
494
- case "LimitExceededException":
495
- case "com.amazonaws.transcribe#LimitExceededException":
496
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
497
- case "NotFoundException":
498
- case "com.amazonaws.transcribe#NotFoundException":
499
- throw await de_NotFoundExceptionRes(parsedOutput, context);
500
- default:
501
- const parsedBody = parsedOutput.body;
502
- return throwDefaultError({
503
- output,
504
- parsedBody,
505
- errorCode,
506
- });
507
- }
508
- };
509
341
  export const de_DeleteCallAnalyticsJobCommand = async (output, context) => {
510
342
  if (output.statusCode >= 300) {
511
- return de_DeleteCallAnalyticsJobCommandError(output, context);
343
+ return de_CommandError(output, context);
512
344
  }
513
345
  const data = await parseBody(output.body, context);
514
346
  let contents = {};
@@ -519,34 +351,9 @@ export const de_DeleteCallAnalyticsJobCommand = async (output, context) => {
519
351
  };
520
352
  return response;
521
353
  };
522
- const de_DeleteCallAnalyticsJobCommandError = async (output, context) => {
523
- const parsedOutput = {
524
- ...output,
525
- body: await parseErrorBody(output.body, context),
526
- };
527
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
528
- switch (errorCode) {
529
- case "BadRequestException":
530
- case "com.amazonaws.transcribe#BadRequestException":
531
- throw await de_BadRequestExceptionRes(parsedOutput, context);
532
- case "InternalFailureException":
533
- case "com.amazonaws.transcribe#InternalFailureException":
534
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
535
- case "LimitExceededException":
536
- case "com.amazonaws.transcribe#LimitExceededException":
537
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
538
- default:
539
- const parsedBody = parsedOutput.body;
540
- return throwDefaultError({
541
- output,
542
- parsedBody,
543
- errorCode,
544
- });
545
- }
546
- };
547
354
  export const de_DeleteLanguageModelCommand = async (output, context) => {
548
355
  if (output.statusCode >= 300) {
549
- return de_DeleteLanguageModelCommandError(output, context);
356
+ return de_CommandError(output, context);
550
357
  }
551
358
  await collectBody(output.body, context);
552
359
  const response = {
@@ -554,34 +361,19 @@ export const de_DeleteLanguageModelCommand = async (output, context) => {
554
361
  };
555
362
  return response;
556
363
  };
557
- const de_DeleteLanguageModelCommandError = async (output, context) => {
558
- const parsedOutput = {
559
- ...output,
560
- body: await parseErrorBody(output.body, context),
561
- };
562
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
563
- switch (errorCode) {
564
- case "BadRequestException":
565
- case "com.amazonaws.transcribe#BadRequestException":
566
- throw await de_BadRequestExceptionRes(parsedOutput, context);
567
- case "InternalFailureException":
568
- case "com.amazonaws.transcribe#InternalFailureException":
569
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
570
- case "LimitExceededException":
571
- case "com.amazonaws.transcribe#LimitExceededException":
572
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
573
- default:
574
- const parsedBody = parsedOutput.body;
575
- return throwDefaultError({
576
- output,
577
- parsedBody,
578
- errorCode,
579
- });
364
+ export const de_DeleteMedicalScribeJobCommand = async (output, context) => {
365
+ if (output.statusCode >= 300) {
366
+ return de_CommandError(output, context);
580
367
  }
368
+ await collectBody(output.body, context);
369
+ const response = {
370
+ $metadata: deserializeMetadata(output),
371
+ };
372
+ return response;
581
373
  };
582
- export const de_DeleteMedicalScribeJobCommand = async (output, context) => {
374
+ export const de_DeleteMedicalTranscriptionJobCommand = async (output, context) => {
583
375
  if (output.statusCode >= 300) {
584
- return de_DeleteMedicalScribeJobCommandError(output, context);
376
+ return de_CommandError(output, context);
585
377
  }
586
378
  await collectBody(output.body, context);
587
379
  const response = {
@@ -589,34 +381,29 @@ export const de_DeleteMedicalScribeJobCommand = async (output, context) => {
589
381
  };
590
382
  return response;
591
383
  };
592
- const de_DeleteMedicalScribeJobCommandError = async (output, context) => {
593
- const parsedOutput = {
594
- ...output,
595
- body: await parseErrorBody(output.body, context),
384
+ export const de_DeleteMedicalVocabularyCommand = async (output, context) => {
385
+ if (output.statusCode >= 300) {
386
+ return de_CommandError(output, context);
387
+ }
388
+ await collectBody(output.body, context);
389
+ const response = {
390
+ $metadata: deserializeMetadata(output),
596
391
  };
597
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
598
- switch (errorCode) {
599
- case "BadRequestException":
600
- case "com.amazonaws.transcribe#BadRequestException":
601
- throw await de_BadRequestExceptionRes(parsedOutput, context);
602
- case "InternalFailureException":
603
- case "com.amazonaws.transcribe#InternalFailureException":
604
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
605
- case "LimitExceededException":
606
- case "com.amazonaws.transcribe#LimitExceededException":
607
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
608
- default:
609
- const parsedBody = parsedOutput.body;
610
- return throwDefaultError({
611
- output,
612
- parsedBody,
613
- errorCode,
614
- });
392
+ return response;
393
+ };
394
+ export const de_DeleteTranscriptionJobCommand = async (output, context) => {
395
+ if (output.statusCode >= 300) {
396
+ return de_CommandError(output, context);
615
397
  }
398
+ await collectBody(output.body, context);
399
+ const response = {
400
+ $metadata: deserializeMetadata(output),
401
+ };
402
+ return response;
616
403
  };
617
- export const de_DeleteMedicalTranscriptionJobCommand = async (output, context) => {
404
+ export const de_DeleteVocabularyCommand = async (output, context) => {
618
405
  if (output.statusCode >= 300) {
619
- return de_DeleteMedicalTranscriptionJobCommandError(output, context);
406
+ return de_CommandError(output, context);
620
407
  }
621
408
  await collectBody(output.body, context);
622
409
  const response = {
@@ -624,145 +411,9 @@ export const de_DeleteMedicalTranscriptionJobCommand = async (output, context) =
624
411
  };
625
412
  return response;
626
413
  };
627
- const de_DeleteMedicalTranscriptionJobCommandError = async (output, context) => {
628
- const parsedOutput = {
629
- ...output,
630
- body: await parseErrorBody(output.body, context),
631
- };
632
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
633
- switch (errorCode) {
634
- case "BadRequestException":
635
- case "com.amazonaws.transcribe#BadRequestException":
636
- throw await de_BadRequestExceptionRes(parsedOutput, context);
637
- case "InternalFailureException":
638
- case "com.amazonaws.transcribe#InternalFailureException":
639
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
640
- case "LimitExceededException":
641
- case "com.amazonaws.transcribe#LimitExceededException":
642
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
643
- default:
644
- const parsedBody = parsedOutput.body;
645
- return throwDefaultError({
646
- output,
647
- parsedBody,
648
- errorCode,
649
- });
650
- }
651
- };
652
- export const de_DeleteMedicalVocabularyCommand = async (output, context) => {
653
- if (output.statusCode >= 300) {
654
- return de_DeleteMedicalVocabularyCommandError(output, context);
655
- }
656
- await collectBody(output.body, context);
657
- const response = {
658
- $metadata: deserializeMetadata(output),
659
- };
660
- return response;
661
- };
662
- const de_DeleteMedicalVocabularyCommandError = async (output, context) => {
663
- const parsedOutput = {
664
- ...output,
665
- body: await parseErrorBody(output.body, context),
666
- };
667
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
668
- switch (errorCode) {
669
- case "BadRequestException":
670
- case "com.amazonaws.transcribe#BadRequestException":
671
- throw await de_BadRequestExceptionRes(parsedOutput, context);
672
- case "InternalFailureException":
673
- case "com.amazonaws.transcribe#InternalFailureException":
674
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
675
- case "LimitExceededException":
676
- case "com.amazonaws.transcribe#LimitExceededException":
677
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
678
- case "NotFoundException":
679
- case "com.amazonaws.transcribe#NotFoundException":
680
- throw await de_NotFoundExceptionRes(parsedOutput, context);
681
- default:
682
- const parsedBody = parsedOutput.body;
683
- return throwDefaultError({
684
- output,
685
- parsedBody,
686
- errorCode,
687
- });
688
- }
689
- };
690
- export const de_DeleteTranscriptionJobCommand = async (output, context) => {
691
- if (output.statusCode >= 300) {
692
- return de_DeleteTranscriptionJobCommandError(output, context);
693
- }
694
- await collectBody(output.body, context);
695
- const response = {
696
- $metadata: deserializeMetadata(output),
697
- };
698
- return response;
699
- };
700
- const de_DeleteTranscriptionJobCommandError = async (output, context) => {
701
- const parsedOutput = {
702
- ...output,
703
- body: await parseErrorBody(output.body, context),
704
- };
705
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
706
- switch (errorCode) {
707
- case "BadRequestException":
708
- case "com.amazonaws.transcribe#BadRequestException":
709
- throw await de_BadRequestExceptionRes(parsedOutput, context);
710
- case "InternalFailureException":
711
- case "com.amazonaws.transcribe#InternalFailureException":
712
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
713
- case "LimitExceededException":
714
- case "com.amazonaws.transcribe#LimitExceededException":
715
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
716
- default:
717
- const parsedBody = parsedOutput.body;
718
- return throwDefaultError({
719
- output,
720
- parsedBody,
721
- errorCode,
722
- });
723
- }
724
- };
725
- export const de_DeleteVocabularyCommand = async (output, context) => {
726
- if (output.statusCode >= 300) {
727
- return de_DeleteVocabularyCommandError(output, context);
728
- }
729
- await collectBody(output.body, context);
730
- const response = {
731
- $metadata: deserializeMetadata(output),
732
- };
733
- return response;
734
- };
735
- const de_DeleteVocabularyCommandError = async (output, context) => {
736
- const parsedOutput = {
737
- ...output,
738
- body: await parseErrorBody(output.body, context),
739
- };
740
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
741
- switch (errorCode) {
742
- case "BadRequestException":
743
- case "com.amazonaws.transcribe#BadRequestException":
744
- throw await de_BadRequestExceptionRes(parsedOutput, context);
745
- case "InternalFailureException":
746
- case "com.amazonaws.transcribe#InternalFailureException":
747
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
748
- case "LimitExceededException":
749
- case "com.amazonaws.transcribe#LimitExceededException":
750
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
751
- case "NotFoundException":
752
- case "com.amazonaws.transcribe#NotFoundException":
753
- throw await de_NotFoundExceptionRes(parsedOutput, context);
754
- default:
755
- const parsedBody = parsedOutput.body;
756
- return throwDefaultError({
757
- output,
758
- parsedBody,
759
- errorCode,
760
- });
761
- }
762
- };
763
414
  export const de_DeleteVocabularyFilterCommand = async (output, context) => {
764
415
  if (output.statusCode >= 300) {
765
- return de_DeleteVocabularyFilterCommandError(output, context);
416
+ return de_CommandError(output, context);
766
417
  }
767
418
  await collectBody(output.body, context);
768
419
  const response = {
@@ -770,37 +421,9 @@ export const de_DeleteVocabularyFilterCommand = async (output, context) => {
770
421
  };
771
422
  return response;
772
423
  };
773
- const de_DeleteVocabularyFilterCommandError = async (output, context) => {
774
- const parsedOutput = {
775
- ...output,
776
- body: await parseErrorBody(output.body, context),
777
- };
778
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
779
- switch (errorCode) {
780
- case "BadRequestException":
781
- case "com.amazonaws.transcribe#BadRequestException":
782
- throw await de_BadRequestExceptionRes(parsedOutput, context);
783
- case "InternalFailureException":
784
- case "com.amazonaws.transcribe#InternalFailureException":
785
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
786
- case "LimitExceededException":
787
- case "com.amazonaws.transcribe#LimitExceededException":
788
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
789
- case "NotFoundException":
790
- case "com.amazonaws.transcribe#NotFoundException":
791
- throw await de_NotFoundExceptionRes(parsedOutput, context);
792
- default:
793
- const parsedBody = parsedOutput.body;
794
- return throwDefaultError({
795
- output,
796
- parsedBody,
797
- errorCode,
798
- });
799
- }
800
- };
801
424
  export const de_DescribeLanguageModelCommand = async (output, context) => {
802
425
  if (output.statusCode >= 300) {
803
- return de_DescribeLanguageModelCommandError(output, context);
426
+ return de_CommandError(output, context);
804
427
  }
805
428
  const data = await parseBody(output.body, context);
806
429
  let contents = {};
@@ -811,37 +434,9 @@ export const de_DescribeLanguageModelCommand = async (output, context) => {
811
434
  };
812
435
  return response;
813
436
  };
814
- const de_DescribeLanguageModelCommandError = async (output, context) => {
815
- const parsedOutput = {
816
- ...output,
817
- body: await parseErrorBody(output.body, context),
818
- };
819
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
820
- switch (errorCode) {
821
- case "BadRequestException":
822
- case "com.amazonaws.transcribe#BadRequestException":
823
- throw await de_BadRequestExceptionRes(parsedOutput, context);
824
- case "InternalFailureException":
825
- case "com.amazonaws.transcribe#InternalFailureException":
826
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
827
- case "LimitExceededException":
828
- case "com.amazonaws.transcribe#LimitExceededException":
829
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
830
- case "NotFoundException":
831
- case "com.amazonaws.transcribe#NotFoundException":
832
- throw await de_NotFoundExceptionRes(parsedOutput, context);
833
- default:
834
- const parsedBody = parsedOutput.body;
835
- return throwDefaultError({
836
- output,
837
- parsedBody,
838
- errorCode,
839
- });
840
- }
841
- };
842
437
  export const de_GetCallAnalyticsCategoryCommand = async (output, context) => {
843
438
  if (output.statusCode >= 300) {
844
- return de_GetCallAnalyticsCategoryCommandError(output, context);
439
+ return de_CommandError(output, context);
845
440
  }
846
441
  const data = await parseBody(output.body, context);
847
442
  let contents = {};
@@ -852,37 +447,9 @@ export const de_GetCallAnalyticsCategoryCommand = async (output, context) => {
852
447
  };
853
448
  return response;
854
449
  };
855
- const de_GetCallAnalyticsCategoryCommandError = async (output, context) => {
856
- const parsedOutput = {
857
- ...output,
858
- body: await parseErrorBody(output.body, context),
859
- };
860
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
861
- switch (errorCode) {
862
- case "BadRequestException":
863
- case "com.amazonaws.transcribe#BadRequestException":
864
- throw await de_BadRequestExceptionRes(parsedOutput, context);
865
- case "InternalFailureException":
866
- case "com.amazonaws.transcribe#InternalFailureException":
867
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
868
- case "LimitExceededException":
869
- case "com.amazonaws.transcribe#LimitExceededException":
870
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
871
- case "NotFoundException":
872
- case "com.amazonaws.transcribe#NotFoundException":
873
- throw await de_NotFoundExceptionRes(parsedOutput, context);
874
- default:
875
- const parsedBody = parsedOutput.body;
876
- return throwDefaultError({
877
- output,
878
- parsedBody,
879
- errorCode,
880
- });
881
- }
882
- };
883
450
  export const de_GetCallAnalyticsJobCommand = async (output, context) => {
884
451
  if (output.statusCode >= 300) {
885
- return de_GetCallAnalyticsJobCommandError(output, context);
452
+ return de_CommandError(output, context);
886
453
  }
887
454
  const data = await parseBody(output.body, context);
888
455
  let contents = {};
@@ -893,37 +460,9 @@ export const de_GetCallAnalyticsJobCommand = async (output, context) => {
893
460
  };
894
461
  return response;
895
462
  };
896
- const de_GetCallAnalyticsJobCommandError = async (output, context) => {
897
- const parsedOutput = {
898
- ...output,
899
- body: await parseErrorBody(output.body, context),
900
- };
901
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
902
- switch (errorCode) {
903
- case "BadRequestException":
904
- case "com.amazonaws.transcribe#BadRequestException":
905
- throw await de_BadRequestExceptionRes(parsedOutput, context);
906
- case "InternalFailureException":
907
- case "com.amazonaws.transcribe#InternalFailureException":
908
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
909
- case "LimitExceededException":
910
- case "com.amazonaws.transcribe#LimitExceededException":
911
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
912
- case "NotFoundException":
913
- case "com.amazonaws.transcribe#NotFoundException":
914
- throw await de_NotFoundExceptionRes(parsedOutput, context);
915
- default:
916
- const parsedBody = parsedOutput.body;
917
- return throwDefaultError({
918
- output,
919
- parsedBody,
920
- errorCode,
921
- });
922
- }
923
- };
924
463
  export const de_GetMedicalScribeJobCommand = async (output, context) => {
925
464
  if (output.statusCode >= 300) {
926
- return de_GetMedicalScribeJobCommandError(output, context);
465
+ return de_CommandError(output, context);
927
466
  }
928
467
  const data = await parseBody(output.body, context);
929
468
  let contents = {};
@@ -934,37 +473,9 @@ export const de_GetMedicalScribeJobCommand = async (output, context) => {
934
473
  };
935
474
  return response;
936
475
  };
937
- const de_GetMedicalScribeJobCommandError = async (output, context) => {
938
- const parsedOutput = {
939
- ...output,
940
- body: await parseErrorBody(output.body, context),
941
- };
942
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
943
- switch (errorCode) {
944
- case "BadRequestException":
945
- case "com.amazonaws.transcribe#BadRequestException":
946
- throw await de_BadRequestExceptionRes(parsedOutput, context);
947
- case "InternalFailureException":
948
- case "com.amazonaws.transcribe#InternalFailureException":
949
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
950
- case "LimitExceededException":
951
- case "com.amazonaws.transcribe#LimitExceededException":
952
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
953
- case "NotFoundException":
954
- case "com.amazonaws.transcribe#NotFoundException":
955
- throw await de_NotFoundExceptionRes(parsedOutput, context);
956
- default:
957
- const parsedBody = parsedOutput.body;
958
- return throwDefaultError({
959
- output,
960
- parsedBody,
961
- errorCode,
962
- });
963
- }
964
- };
965
476
  export const de_GetMedicalTranscriptionJobCommand = async (output, context) => {
966
477
  if (output.statusCode >= 300) {
967
- return de_GetMedicalTranscriptionJobCommandError(output, context);
478
+ return de_CommandError(output, context);
968
479
  }
969
480
  const data = await parseBody(output.body, context);
970
481
  let contents = {};
@@ -975,37 +486,9 @@ export const de_GetMedicalTranscriptionJobCommand = async (output, context) => {
975
486
  };
976
487
  return response;
977
488
  };
978
- const de_GetMedicalTranscriptionJobCommandError = async (output, context) => {
979
- const parsedOutput = {
980
- ...output,
981
- body: await parseErrorBody(output.body, context),
982
- };
983
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
984
- switch (errorCode) {
985
- case "BadRequestException":
986
- case "com.amazonaws.transcribe#BadRequestException":
987
- throw await de_BadRequestExceptionRes(parsedOutput, context);
988
- case "InternalFailureException":
989
- case "com.amazonaws.transcribe#InternalFailureException":
990
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
991
- case "LimitExceededException":
992
- case "com.amazonaws.transcribe#LimitExceededException":
993
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
994
- case "NotFoundException":
995
- case "com.amazonaws.transcribe#NotFoundException":
996
- throw await de_NotFoundExceptionRes(parsedOutput, context);
997
- default:
998
- const parsedBody = parsedOutput.body;
999
- return throwDefaultError({
1000
- output,
1001
- parsedBody,
1002
- errorCode,
1003
- });
1004
- }
1005
- };
1006
489
  export const de_GetMedicalVocabularyCommand = async (output, context) => {
1007
490
  if (output.statusCode >= 300) {
1008
- return de_GetMedicalVocabularyCommandError(output, context);
491
+ return de_CommandError(output, context);
1009
492
  }
1010
493
  const data = await parseBody(output.body, context);
1011
494
  let contents = {};
@@ -1016,37 +499,9 @@ export const de_GetMedicalVocabularyCommand = async (output, context) => {
1016
499
  };
1017
500
  return response;
1018
501
  };
1019
- const de_GetMedicalVocabularyCommandError = async (output, context) => {
1020
- const parsedOutput = {
1021
- ...output,
1022
- body: await parseErrorBody(output.body, context),
1023
- };
1024
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1025
- switch (errorCode) {
1026
- case "BadRequestException":
1027
- case "com.amazonaws.transcribe#BadRequestException":
1028
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1029
- case "InternalFailureException":
1030
- case "com.amazonaws.transcribe#InternalFailureException":
1031
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1032
- case "LimitExceededException":
1033
- case "com.amazonaws.transcribe#LimitExceededException":
1034
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1035
- case "NotFoundException":
1036
- case "com.amazonaws.transcribe#NotFoundException":
1037
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1038
- default:
1039
- const parsedBody = parsedOutput.body;
1040
- return throwDefaultError({
1041
- output,
1042
- parsedBody,
1043
- errorCode,
1044
- });
1045
- }
1046
- };
1047
502
  export const de_GetTranscriptionJobCommand = async (output, context) => {
1048
503
  if (output.statusCode >= 300) {
1049
- return de_GetTranscriptionJobCommandError(output, context);
504
+ return de_CommandError(output, context);
1050
505
  }
1051
506
  const data = await parseBody(output.body, context);
1052
507
  let contents = {};
@@ -1057,37 +512,9 @@ export const de_GetTranscriptionJobCommand = async (output, context) => {
1057
512
  };
1058
513
  return response;
1059
514
  };
1060
- const de_GetTranscriptionJobCommandError = async (output, context) => {
1061
- const parsedOutput = {
1062
- ...output,
1063
- body: await parseErrorBody(output.body, context),
1064
- };
1065
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1066
- switch (errorCode) {
1067
- case "BadRequestException":
1068
- case "com.amazonaws.transcribe#BadRequestException":
1069
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1070
- case "InternalFailureException":
1071
- case "com.amazonaws.transcribe#InternalFailureException":
1072
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1073
- case "LimitExceededException":
1074
- case "com.amazonaws.transcribe#LimitExceededException":
1075
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1076
- case "NotFoundException":
1077
- case "com.amazonaws.transcribe#NotFoundException":
1078
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1079
- default:
1080
- const parsedBody = parsedOutput.body;
1081
- return throwDefaultError({
1082
- output,
1083
- parsedBody,
1084
- errorCode,
1085
- });
1086
- }
1087
- };
1088
515
  export const de_GetVocabularyCommand = async (output, context) => {
1089
516
  if (output.statusCode >= 300) {
1090
- return de_GetVocabularyCommandError(output, context);
517
+ return de_CommandError(output, context);
1091
518
  }
1092
519
  const data = await parseBody(output.body, context);
1093
520
  let contents = {};
@@ -1098,37 +525,9 @@ export const de_GetVocabularyCommand = async (output, context) => {
1098
525
  };
1099
526
  return response;
1100
527
  };
1101
- const de_GetVocabularyCommandError = async (output, context) => {
1102
- const parsedOutput = {
1103
- ...output,
1104
- body: await parseErrorBody(output.body, context),
1105
- };
1106
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1107
- switch (errorCode) {
1108
- case "BadRequestException":
1109
- case "com.amazonaws.transcribe#BadRequestException":
1110
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1111
- case "InternalFailureException":
1112
- case "com.amazonaws.transcribe#InternalFailureException":
1113
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1114
- case "LimitExceededException":
1115
- case "com.amazonaws.transcribe#LimitExceededException":
1116
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1117
- case "NotFoundException":
1118
- case "com.amazonaws.transcribe#NotFoundException":
1119
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1120
- default:
1121
- const parsedBody = parsedOutput.body;
1122
- return throwDefaultError({
1123
- output,
1124
- parsedBody,
1125
- errorCode,
1126
- });
1127
- }
1128
- };
1129
528
  export const de_GetVocabularyFilterCommand = async (output, context) => {
1130
529
  if (output.statusCode >= 300) {
1131
- return de_GetVocabularyFilterCommandError(output, context);
530
+ return de_CommandError(output, context);
1132
531
  }
1133
532
  const data = await parseBody(output.body, context);
1134
533
  let contents = {};
@@ -1139,502 +538,165 @@ export const de_GetVocabularyFilterCommand = async (output, context) => {
1139
538
  };
1140
539
  return response;
1141
540
  };
1142
- const de_GetVocabularyFilterCommandError = async (output, context) => {
1143
- const parsedOutput = {
1144
- ...output,
1145
- body: await parseErrorBody(output.body, context),
1146
- };
1147
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1148
- switch (errorCode) {
1149
- case "BadRequestException":
1150
- case "com.amazonaws.transcribe#BadRequestException":
1151
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1152
- case "InternalFailureException":
1153
- case "com.amazonaws.transcribe#InternalFailureException":
1154
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1155
- case "LimitExceededException":
1156
- case "com.amazonaws.transcribe#LimitExceededException":
1157
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1158
- case "NotFoundException":
1159
- case "com.amazonaws.transcribe#NotFoundException":
1160
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1161
- default:
1162
- const parsedBody = parsedOutput.body;
1163
- return throwDefaultError({
1164
- output,
1165
- parsedBody,
1166
- errorCode,
1167
- });
1168
- }
1169
- };
1170
541
  export const de_ListCallAnalyticsCategoriesCommand = async (output, context) => {
1171
542
  if (output.statusCode >= 300) {
1172
- return de_ListCallAnalyticsCategoriesCommandError(output, context);
1173
- }
1174
- const data = await parseBody(output.body, context);
1175
- let contents = {};
1176
- contents = de_ListCallAnalyticsCategoriesResponse(data, context);
1177
- const response = {
1178
- $metadata: deserializeMetadata(output),
1179
- ...contents,
1180
- };
1181
- return response;
1182
- };
1183
- const de_ListCallAnalyticsCategoriesCommandError = async (output, context) => {
1184
- const parsedOutput = {
1185
- ...output,
1186
- body: await parseErrorBody(output.body, context),
1187
- };
1188
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1189
- switch (errorCode) {
1190
- case "BadRequestException":
1191
- case "com.amazonaws.transcribe#BadRequestException":
1192
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1193
- case "InternalFailureException":
1194
- case "com.amazonaws.transcribe#InternalFailureException":
1195
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1196
- case "LimitExceededException":
1197
- case "com.amazonaws.transcribe#LimitExceededException":
1198
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1199
- default:
1200
- const parsedBody = parsedOutput.body;
1201
- return throwDefaultError({
1202
- output,
1203
- parsedBody,
1204
- errorCode,
1205
- });
1206
- }
1207
- };
1208
- export const de_ListCallAnalyticsJobsCommand = async (output, context) => {
1209
- if (output.statusCode >= 300) {
1210
- return de_ListCallAnalyticsJobsCommandError(output, context);
1211
- }
1212
- const data = await parseBody(output.body, context);
1213
- let contents = {};
1214
- contents = de_ListCallAnalyticsJobsResponse(data, context);
1215
- const response = {
1216
- $metadata: deserializeMetadata(output),
1217
- ...contents,
1218
- };
1219
- return response;
1220
- };
1221
- const de_ListCallAnalyticsJobsCommandError = async (output, context) => {
1222
- const parsedOutput = {
1223
- ...output,
1224
- body: await parseErrorBody(output.body, context),
1225
- };
1226
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1227
- switch (errorCode) {
1228
- case "BadRequestException":
1229
- case "com.amazonaws.transcribe#BadRequestException":
1230
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1231
- case "InternalFailureException":
1232
- case "com.amazonaws.transcribe#InternalFailureException":
1233
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1234
- case "LimitExceededException":
1235
- case "com.amazonaws.transcribe#LimitExceededException":
1236
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1237
- default:
1238
- const parsedBody = parsedOutput.body;
1239
- return throwDefaultError({
1240
- output,
1241
- parsedBody,
1242
- errorCode,
1243
- });
1244
- }
1245
- };
1246
- export const de_ListLanguageModelsCommand = async (output, context) => {
1247
- if (output.statusCode >= 300) {
1248
- return de_ListLanguageModelsCommandError(output, context);
543
+ return de_CommandError(output, context);
1249
544
  }
1250
545
  const data = await parseBody(output.body, context);
1251
546
  let contents = {};
1252
- contents = de_ListLanguageModelsResponse(data, context);
547
+ contents = de_ListCallAnalyticsCategoriesResponse(data, context);
1253
548
  const response = {
1254
549
  $metadata: deserializeMetadata(output),
1255
550
  ...contents,
1256
551
  };
1257
552
  return response;
1258
553
  };
1259
- const de_ListLanguageModelsCommandError = async (output, context) => {
1260
- const parsedOutput = {
1261
- ...output,
1262
- body: await parseErrorBody(output.body, context),
1263
- };
1264
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1265
- switch (errorCode) {
1266
- case "BadRequestException":
1267
- case "com.amazonaws.transcribe#BadRequestException":
1268
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1269
- case "InternalFailureException":
1270
- case "com.amazonaws.transcribe#InternalFailureException":
1271
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1272
- case "LimitExceededException":
1273
- case "com.amazonaws.transcribe#LimitExceededException":
1274
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1275
- default:
1276
- const parsedBody = parsedOutput.body;
1277
- return throwDefaultError({
1278
- output,
1279
- parsedBody,
1280
- errorCode,
1281
- });
1282
- }
1283
- };
1284
- export const de_ListMedicalScribeJobsCommand = async (output, context) => {
554
+ export const de_ListCallAnalyticsJobsCommand = async (output, context) => {
1285
555
  if (output.statusCode >= 300) {
1286
- return de_ListMedicalScribeJobsCommandError(output, context);
556
+ return de_CommandError(output, context);
1287
557
  }
1288
558
  const data = await parseBody(output.body, context);
1289
559
  let contents = {};
1290
- contents = de_ListMedicalScribeJobsResponse(data, context);
560
+ contents = de_ListCallAnalyticsJobsResponse(data, context);
1291
561
  const response = {
1292
562
  $metadata: deserializeMetadata(output),
1293
563
  ...contents,
1294
564
  };
1295
565
  return response;
1296
566
  };
1297
- const de_ListMedicalScribeJobsCommandError = async (output, context) => {
1298
- const parsedOutput = {
1299
- ...output,
1300
- body: await parseErrorBody(output.body, context),
1301
- };
1302
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1303
- switch (errorCode) {
1304
- case "BadRequestException":
1305
- case "com.amazonaws.transcribe#BadRequestException":
1306
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1307
- case "InternalFailureException":
1308
- case "com.amazonaws.transcribe#InternalFailureException":
1309
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1310
- case "LimitExceededException":
1311
- case "com.amazonaws.transcribe#LimitExceededException":
1312
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1313
- default:
1314
- const parsedBody = parsedOutput.body;
1315
- return throwDefaultError({
1316
- output,
1317
- parsedBody,
1318
- errorCode,
1319
- });
1320
- }
1321
- };
1322
- export const de_ListMedicalTranscriptionJobsCommand = async (output, context) => {
567
+ export const de_ListLanguageModelsCommand = async (output, context) => {
1323
568
  if (output.statusCode >= 300) {
1324
- return de_ListMedicalTranscriptionJobsCommandError(output, context);
569
+ return de_CommandError(output, context);
1325
570
  }
1326
571
  const data = await parseBody(output.body, context);
1327
572
  let contents = {};
1328
- contents = de_ListMedicalTranscriptionJobsResponse(data, context);
573
+ contents = de_ListLanguageModelsResponse(data, context);
1329
574
  const response = {
1330
575
  $metadata: deserializeMetadata(output),
1331
576
  ...contents,
1332
577
  };
1333
578
  return response;
1334
579
  };
1335
- const de_ListMedicalTranscriptionJobsCommandError = async (output, context) => {
1336
- const parsedOutput = {
1337
- ...output,
1338
- body: await parseErrorBody(output.body, context),
1339
- };
1340
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1341
- switch (errorCode) {
1342
- case "BadRequestException":
1343
- case "com.amazonaws.transcribe#BadRequestException":
1344
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1345
- case "InternalFailureException":
1346
- case "com.amazonaws.transcribe#InternalFailureException":
1347
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1348
- case "LimitExceededException":
1349
- case "com.amazonaws.transcribe#LimitExceededException":
1350
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1351
- default:
1352
- const parsedBody = parsedOutput.body;
1353
- return throwDefaultError({
1354
- output,
1355
- parsedBody,
1356
- errorCode,
1357
- });
1358
- }
1359
- };
1360
- export const de_ListMedicalVocabulariesCommand = async (output, context) => {
580
+ export const de_ListMedicalScribeJobsCommand = async (output, context) => {
1361
581
  if (output.statusCode >= 300) {
1362
- return de_ListMedicalVocabulariesCommandError(output, context);
582
+ return de_CommandError(output, context);
1363
583
  }
1364
584
  const data = await parseBody(output.body, context);
1365
585
  let contents = {};
1366
- contents = de_ListMedicalVocabulariesResponse(data, context);
586
+ contents = de_ListMedicalScribeJobsResponse(data, context);
1367
587
  const response = {
1368
588
  $metadata: deserializeMetadata(output),
1369
589
  ...contents,
1370
590
  };
1371
591
  return response;
1372
592
  };
1373
- const de_ListMedicalVocabulariesCommandError = async (output, context) => {
1374
- const parsedOutput = {
1375
- ...output,
1376
- body: await parseErrorBody(output.body, context),
1377
- };
1378
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1379
- switch (errorCode) {
1380
- case "BadRequestException":
1381
- case "com.amazonaws.transcribe#BadRequestException":
1382
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1383
- case "InternalFailureException":
1384
- case "com.amazonaws.transcribe#InternalFailureException":
1385
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1386
- case "LimitExceededException":
1387
- case "com.amazonaws.transcribe#LimitExceededException":
1388
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1389
- default:
1390
- const parsedBody = parsedOutput.body;
1391
- return throwDefaultError({
1392
- output,
1393
- parsedBody,
1394
- errorCode,
1395
- });
1396
- }
1397
- };
1398
- export const de_ListTagsForResourceCommand = async (output, context) => {
593
+ export const de_ListMedicalTranscriptionJobsCommand = async (output, context) => {
1399
594
  if (output.statusCode >= 300) {
1400
- return de_ListTagsForResourceCommandError(output, context);
595
+ return de_CommandError(output, context);
1401
596
  }
1402
597
  const data = await parseBody(output.body, context);
1403
598
  let contents = {};
1404
- contents = _json(data);
599
+ contents = de_ListMedicalTranscriptionJobsResponse(data, context);
1405
600
  const response = {
1406
601
  $metadata: deserializeMetadata(output),
1407
602
  ...contents,
1408
603
  };
1409
604
  return response;
1410
605
  };
1411
- const de_ListTagsForResourceCommandError = async (output, context) => {
1412
- const parsedOutput = {
1413
- ...output,
1414
- body: await parseErrorBody(output.body, context),
1415
- };
1416
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1417
- switch (errorCode) {
1418
- case "BadRequestException":
1419
- case "com.amazonaws.transcribe#BadRequestException":
1420
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1421
- case "InternalFailureException":
1422
- case "com.amazonaws.transcribe#InternalFailureException":
1423
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1424
- case "LimitExceededException":
1425
- case "com.amazonaws.transcribe#LimitExceededException":
1426
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1427
- case "NotFoundException":
1428
- case "com.amazonaws.transcribe#NotFoundException":
1429
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1430
- default:
1431
- const parsedBody = parsedOutput.body;
1432
- return throwDefaultError({
1433
- output,
1434
- parsedBody,
1435
- errorCode,
1436
- });
1437
- }
1438
- };
1439
- export const de_ListTranscriptionJobsCommand = async (output, context) => {
606
+ export const de_ListMedicalVocabulariesCommand = async (output, context) => {
1440
607
  if (output.statusCode >= 300) {
1441
- return de_ListTranscriptionJobsCommandError(output, context);
608
+ return de_CommandError(output, context);
1442
609
  }
1443
610
  const data = await parseBody(output.body, context);
1444
611
  let contents = {};
1445
- contents = de_ListTranscriptionJobsResponse(data, context);
612
+ contents = de_ListMedicalVocabulariesResponse(data, context);
1446
613
  const response = {
1447
614
  $metadata: deserializeMetadata(output),
1448
615
  ...contents,
1449
616
  };
1450
617
  return response;
1451
618
  };
1452
- const de_ListTranscriptionJobsCommandError = async (output, context) => {
1453
- const parsedOutput = {
1454
- ...output,
1455
- body: await parseErrorBody(output.body, context),
1456
- };
1457
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1458
- switch (errorCode) {
1459
- case "BadRequestException":
1460
- case "com.amazonaws.transcribe#BadRequestException":
1461
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1462
- case "InternalFailureException":
1463
- case "com.amazonaws.transcribe#InternalFailureException":
1464
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1465
- case "LimitExceededException":
1466
- case "com.amazonaws.transcribe#LimitExceededException":
1467
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1468
- default:
1469
- const parsedBody = parsedOutput.body;
1470
- return throwDefaultError({
1471
- output,
1472
- parsedBody,
1473
- errorCode,
1474
- });
1475
- }
1476
- };
1477
- export const de_ListVocabulariesCommand = async (output, context) => {
619
+ export const de_ListTagsForResourceCommand = async (output, context) => {
1478
620
  if (output.statusCode >= 300) {
1479
- return de_ListVocabulariesCommandError(output, context);
621
+ return de_CommandError(output, context);
1480
622
  }
1481
623
  const data = await parseBody(output.body, context);
1482
624
  let contents = {};
1483
- contents = de_ListVocabulariesResponse(data, context);
625
+ contents = _json(data);
1484
626
  const response = {
1485
627
  $metadata: deserializeMetadata(output),
1486
628
  ...contents,
1487
629
  };
1488
630
  return response;
1489
631
  };
1490
- const de_ListVocabulariesCommandError = async (output, context) => {
1491
- const parsedOutput = {
1492
- ...output,
1493
- body: await parseErrorBody(output.body, context),
1494
- };
1495
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1496
- switch (errorCode) {
1497
- case "BadRequestException":
1498
- case "com.amazonaws.transcribe#BadRequestException":
1499
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1500
- case "InternalFailureException":
1501
- case "com.amazonaws.transcribe#InternalFailureException":
1502
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1503
- case "LimitExceededException":
1504
- case "com.amazonaws.transcribe#LimitExceededException":
1505
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1506
- default:
1507
- const parsedBody = parsedOutput.body;
1508
- return throwDefaultError({
1509
- output,
1510
- parsedBody,
1511
- errorCode,
1512
- });
1513
- }
1514
- };
1515
- export const de_ListVocabularyFiltersCommand = async (output, context) => {
632
+ export const de_ListTranscriptionJobsCommand = async (output, context) => {
1516
633
  if (output.statusCode >= 300) {
1517
- return de_ListVocabularyFiltersCommandError(output, context);
634
+ return de_CommandError(output, context);
1518
635
  }
1519
636
  const data = await parseBody(output.body, context);
1520
637
  let contents = {};
1521
- contents = de_ListVocabularyFiltersResponse(data, context);
638
+ contents = de_ListTranscriptionJobsResponse(data, context);
1522
639
  const response = {
1523
640
  $metadata: deserializeMetadata(output),
1524
641
  ...contents,
1525
642
  };
1526
643
  return response;
1527
644
  };
1528
- const de_ListVocabularyFiltersCommandError = async (output, context) => {
1529
- const parsedOutput = {
1530
- ...output,
1531
- body: await parseErrorBody(output.body, context),
1532
- };
1533
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1534
- switch (errorCode) {
1535
- case "BadRequestException":
1536
- case "com.amazonaws.transcribe#BadRequestException":
1537
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1538
- case "InternalFailureException":
1539
- case "com.amazonaws.transcribe#InternalFailureException":
1540
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1541
- case "LimitExceededException":
1542
- case "com.amazonaws.transcribe#LimitExceededException":
1543
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1544
- default:
1545
- const parsedBody = parsedOutput.body;
1546
- return throwDefaultError({
1547
- output,
1548
- parsedBody,
1549
- errorCode,
1550
- });
1551
- }
1552
- };
1553
- export const de_StartCallAnalyticsJobCommand = async (output, context) => {
645
+ export const de_ListVocabulariesCommand = async (output, context) => {
1554
646
  if (output.statusCode >= 300) {
1555
- return de_StartCallAnalyticsJobCommandError(output, context);
647
+ return de_CommandError(output, context);
1556
648
  }
1557
649
  const data = await parseBody(output.body, context);
1558
650
  let contents = {};
1559
- contents = de_StartCallAnalyticsJobResponse(data, context);
651
+ contents = de_ListVocabulariesResponse(data, context);
1560
652
  const response = {
1561
653
  $metadata: deserializeMetadata(output),
1562
654
  ...contents,
1563
655
  };
1564
656
  return response;
1565
657
  };
1566
- const de_StartCallAnalyticsJobCommandError = async (output, context) => {
1567
- const parsedOutput = {
1568
- ...output,
1569
- body: await parseErrorBody(output.body, context),
1570
- };
1571
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1572
- switch (errorCode) {
1573
- case "BadRequestException":
1574
- case "com.amazonaws.transcribe#BadRequestException":
1575
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1576
- case "ConflictException":
1577
- case "com.amazonaws.transcribe#ConflictException":
1578
- throw await de_ConflictExceptionRes(parsedOutput, context);
1579
- case "InternalFailureException":
1580
- case "com.amazonaws.transcribe#InternalFailureException":
1581
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1582
- case "LimitExceededException":
1583
- case "com.amazonaws.transcribe#LimitExceededException":
1584
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1585
- default:
1586
- const parsedBody = parsedOutput.body;
1587
- return throwDefaultError({
1588
- output,
1589
- parsedBody,
1590
- errorCode,
1591
- });
1592
- }
1593
- };
1594
- export const de_StartMedicalScribeJobCommand = async (output, context) => {
658
+ export const de_ListVocabularyFiltersCommand = async (output, context) => {
1595
659
  if (output.statusCode >= 300) {
1596
- return de_StartMedicalScribeJobCommandError(output, context);
660
+ return de_CommandError(output, context);
1597
661
  }
1598
662
  const data = await parseBody(output.body, context);
1599
663
  let contents = {};
1600
- contents = de_StartMedicalScribeJobResponse(data, context);
664
+ contents = de_ListVocabularyFiltersResponse(data, context);
1601
665
  const response = {
1602
666
  $metadata: deserializeMetadata(output),
1603
667
  ...contents,
1604
668
  };
1605
669
  return response;
1606
670
  };
1607
- const de_StartMedicalScribeJobCommandError = async (output, context) => {
1608
- const parsedOutput = {
1609
- ...output,
1610
- body: await parseErrorBody(output.body, context),
671
+ export const de_StartCallAnalyticsJobCommand = async (output, context) => {
672
+ if (output.statusCode >= 300) {
673
+ return de_CommandError(output, context);
674
+ }
675
+ const data = await parseBody(output.body, context);
676
+ let contents = {};
677
+ contents = de_StartCallAnalyticsJobResponse(data, context);
678
+ const response = {
679
+ $metadata: deserializeMetadata(output),
680
+ ...contents,
1611
681
  };
1612
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1613
- switch (errorCode) {
1614
- case "BadRequestException":
1615
- case "com.amazonaws.transcribe#BadRequestException":
1616
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1617
- case "ConflictException":
1618
- case "com.amazonaws.transcribe#ConflictException":
1619
- throw await de_ConflictExceptionRes(parsedOutput, context);
1620
- case "InternalFailureException":
1621
- case "com.amazonaws.transcribe#InternalFailureException":
1622
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1623
- case "LimitExceededException":
1624
- case "com.amazonaws.transcribe#LimitExceededException":
1625
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1626
- default:
1627
- const parsedBody = parsedOutput.body;
1628
- return throwDefaultError({
1629
- output,
1630
- parsedBody,
1631
- errorCode,
1632
- });
682
+ return response;
683
+ };
684
+ export const de_StartMedicalScribeJobCommand = async (output, context) => {
685
+ if (output.statusCode >= 300) {
686
+ return de_CommandError(output, context);
1633
687
  }
688
+ const data = await parseBody(output.body, context);
689
+ let contents = {};
690
+ contents = de_StartMedicalScribeJobResponse(data, context);
691
+ const response = {
692
+ $metadata: deserializeMetadata(output),
693
+ ...contents,
694
+ };
695
+ return response;
1634
696
  };
1635
697
  export const de_StartMedicalTranscriptionJobCommand = async (output, context) => {
1636
698
  if (output.statusCode >= 300) {
1637
- return de_StartMedicalTranscriptionJobCommandError(output, context);
699
+ return de_CommandError(output, context);
1638
700
  }
1639
701
  const data = await parseBody(output.body, context);
1640
702
  let contents = {};
@@ -1645,37 +707,9 @@ export const de_StartMedicalTranscriptionJobCommand = async (output, context) =>
1645
707
  };
1646
708
  return response;
1647
709
  };
1648
- const de_StartMedicalTranscriptionJobCommandError = async (output, context) => {
1649
- const parsedOutput = {
1650
- ...output,
1651
- body: await parseErrorBody(output.body, context),
1652
- };
1653
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1654
- switch (errorCode) {
1655
- case "BadRequestException":
1656
- case "com.amazonaws.transcribe#BadRequestException":
1657
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1658
- case "ConflictException":
1659
- case "com.amazonaws.transcribe#ConflictException":
1660
- throw await de_ConflictExceptionRes(parsedOutput, context);
1661
- case "InternalFailureException":
1662
- case "com.amazonaws.transcribe#InternalFailureException":
1663
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1664
- case "LimitExceededException":
1665
- case "com.amazonaws.transcribe#LimitExceededException":
1666
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1667
- default:
1668
- const parsedBody = parsedOutput.body;
1669
- return throwDefaultError({
1670
- output,
1671
- parsedBody,
1672
- errorCode,
1673
- });
1674
- }
1675
- };
1676
710
  export const de_StartTranscriptionJobCommand = async (output, context) => {
1677
711
  if (output.statusCode >= 300) {
1678
- return de_StartTranscriptionJobCommandError(output, context);
712
+ return de_CommandError(output, context);
1679
713
  }
1680
714
  const data = await parseBody(output.body, context);
1681
715
  let contents = {};
@@ -1686,37 +720,9 @@ export const de_StartTranscriptionJobCommand = async (output, context) => {
1686
720
  };
1687
721
  return response;
1688
722
  };
1689
- const de_StartTranscriptionJobCommandError = async (output, context) => {
1690
- const parsedOutput = {
1691
- ...output,
1692
- body: await parseErrorBody(output.body, context),
1693
- };
1694
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1695
- switch (errorCode) {
1696
- case "BadRequestException":
1697
- case "com.amazonaws.transcribe#BadRequestException":
1698
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1699
- case "ConflictException":
1700
- case "com.amazonaws.transcribe#ConflictException":
1701
- throw await de_ConflictExceptionRes(parsedOutput, context);
1702
- case "InternalFailureException":
1703
- case "com.amazonaws.transcribe#InternalFailureException":
1704
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1705
- case "LimitExceededException":
1706
- case "com.amazonaws.transcribe#LimitExceededException":
1707
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1708
- default:
1709
- const parsedBody = parsedOutput.body;
1710
- return throwDefaultError({
1711
- output,
1712
- parsedBody,
1713
- errorCode,
1714
- });
1715
- }
1716
- };
1717
723
  export const de_TagResourceCommand = async (output, context) => {
1718
724
  if (output.statusCode >= 300) {
1719
- return de_TagResourceCommandError(output, context);
725
+ return de_CommandError(output, context);
1720
726
  }
1721
727
  const data = await parseBody(output.body, context);
1722
728
  let contents = {};
@@ -1727,40 +733,9 @@ export const de_TagResourceCommand = async (output, context) => {
1727
733
  };
1728
734
  return response;
1729
735
  };
1730
- const de_TagResourceCommandError = async (output, context) => {
1731
- const parsedOutput = {
1732
- ...output,
1733
- body: await parseErrorBody(output.body, context),
1734
- };
1735
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1736
- switch (errorCode) {
1737
- case "BadRequestException":
1738
- case "com.amazonaws.transcribe#BadRequestException":
1739
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1740
- case "ConflictException":
1741
- case "com.amazonaws.transcribe#ConflictException":
1742
- throw await de_ConflictExceptionRes(parsedOutput, context);
1743
- case "InternalFailureException":
1744
- case "com.amazonaws.transcribe#InternalFailureException":
1745
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1746
- case "LimitExceededException":
1747
- case "com.amazonaws.transcribe#LimitExceededException":
1748
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1749
- case "NotFoundException":
1750
- case "com.amazonaws.transcribe#NotFoundException":
1751
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1752
- default:
1753
- const parsedBody = parsedOutput.body;
1754
- return throwDefaultError({
1755
- output,
1756
- parsedBody,
1757
- errorCode,
1758
- });
1759
- }
1760
- };
1761
736
  export const de_UntagResourceCommand = async (output, context) => {
1762
737
  if (output.statusCode >= 300) {
1763
- return de_UntagResourceCommandError(output, context);
738
+ return de_CommandError(output, context);
1764
739
  }
1765
740
  const data = await parseBody(output.body, context);
1766
741
  let contents = {};
@@ -1771,40 +746,9 @@ export const de_UntagResourceCommand = async (output, context) => {
1771
746
  };
1772
747
  return response;
1773
748
  };
1774
- const de_UntagResourceCommandError = async (output, context) => {
1775
- const parsedOutput = {
1776
- ...output,
1777
- body: await parseErrorBody(output.body, context),
1778
- };
1779
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1780
- switch (errorCode) {
1781
- case "BadRequestException":
1782
- case "com.amazonaws.transcribe#BadRequestException":
1783
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1784
- case "ConflictException":
1785
- case "com.amazonaws.transcribe#ConflictException":
1786
- throw await de_ConflictExceptionRes(parsedOutput, context);
1787
- case "InternalFailureException":
1788
- case "com.amazonaws.transcribe#InternalFailureException":
1789
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1790
- case "LimitExceededException":
1791
- case "com.amazonaws.transcribe#LimitExceededException":
1792
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1793
- case "NotFoundException":
1794
- case "com.amazonaws.transcribe#NotFoundException":
1795
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1796
- default:
1797
- const parsedBody = parsedOutput.body;
1798
- return throwDefaultError({
1799
- output,
1800
- parsedBody,
1801
- errorCode,
1802
- });
1803
- }
1804
- };
1805
749
  export const de_UpdateCallAnalyticsCategoryCommand = async (output, context) => {
1806
750
  if (output.statusCode >= 300) {
1807
- return de_UpdateCallAnalyticsCategoryCommandError(output, context);
751
+ return de_CommandError(output, context);
1808
752
  }
1809
753
  const data = await parseBody(output.body, context);
1810
754
  let contents = {};
@@ -1815,40 +759,9 @@ export const de_UpdateCallAnalyticsCategoryCommand = async (output, context) =>
1815
759
  };
1816
760
  return response;
1817
761
  };
1818
- const de_UpdateCallAnalyticsCategoryCommandError = async (output, context) => {
1819
- const parsedOutput = {
1820
- ...output,
1821
- body: await parseErrorBody(output.body, context),
1822
- };
1823
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1824
- switch (errorCode) {
1825
- case "BadRequestException":
1826
- case "com.amazonaws.transcribe#BadRequestException":
1827
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1828
- case "ConflictException":
1829
- case "com.amazonaws.transcribe#ConflictException":
1830
- throw await de_ConflictExceptionRes(parsedOutput, context);
1831
- case "InternalFailureException":
1832
- case "com.amazonaws.transcribe#InternalFailureException":
1833
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1834
- case "LimitExceededException":
1835
- case "com.amazonaws.transcribe#LimitExceededException":
1836
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1837
- case "NotFoundException":
1838
- case "com.amazonaws.transcribe#NotFoundException":
1839
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1840
- default:
1841
- const parsedBody = parsedOutput.body;
1842
- return throwDefaultError({
1843
- output,
1844
- parsedBody,
1845
- errorCode,
1846
- });
1847
- }
1848
- };
1849
762
  export const de_UpdateMedicalVocabularyCommand = async (output, context) => {
1850
763
  if (output.statusCode >= 300) {
1851
- return de_UpdateMedicalVocabularyCommandError(output, context);
764
+ return de_CommandError(output, context);
1852
765
  }
1853
766
  const data = await parseBody(output.body, context);
1854
767
  let contents = {};
@@ -1859,40 +772,9 @@ export const de_UpdateMedicalVocabularyCommand = async (output, context) => {
1859
772
  };
1860
773
  return response;
1861
774
  };
1862
- const de_UpdateMedicalVocabularyCommandError = async (output, context) => {
1863
- const parsedOutput = {
1864
- ...output,
1865
- body: await parseErrorBody(output.body, context),
1866
- };
1867
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1868
- switch (errorCode) {
1869
- case "BadRequestException":
1870
- case "com.amazonaws.transcribe#BadRequestException":
1871
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1872
- case "ConflictException":
1873
- case "com.amazonaws.transcribe#ConflictException":
1874
- throw await de_ConflictExceptionRes(parsedOutput, context);
1875
- case "InternalFailureException":
1876
- case "com.amazonaws.transcribe#InternalFailureException":
1877
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1878
- case "LimitExceededException":
1879
- case "com.amazonaws.transcribe#LimitExceededException":
1880
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1881
- case "NotFoundException":
1882
- case "com.amazonaws.transcribe#NotFoundException":
1883
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1884
- default:
1885
- const parsedBody = parsedOutput.body;
1886
- return throwDefaultError({
1887
- output,
1888
- parsedBody,
1889
- errorCode,
1890
- });
1891
- }
1892
- };
1893
775
  export const de_UpdateVocabularyCommand = async (output, context) => {
1894
776
  if (output.statusCode >= 300) {
1895
- return de_UpdateVocabularyCommandError(output, context);
777
+ return de_CommandError(output, context);
1896
778
  }
1897
779
  const data = await parseBody(output.body, context);
1898
780
  let contents = {};
@@ -1903,40 +785,9 @@ export const de_UpdateVocabularyCommand = async (output, context) => {
1903
785
  };
1904
786
  return response;
1905
787
  };
1906
- const de_UpdateVocabularyCommandError = async (output, context) => {
1907
- const parsedOutput = {
1908
- ...output,
1909
- body: await parseErrorBody(output.body, context),
1910
- };
1911
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1912
- switch (errorCode) {
1913
- case "BadRequestException":
1914
- case "com.amazonaws.transcribe#BadRequestException":
1915
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1916
- case "ConflictException":
1917
- case "com.amazonaws.transcribe#ConflictException":
1918
- throw await de_ConflictExceptionRes(parsedOutput, context);
1919
- case "InternalFailureException":
1920
- case "com.amazonaws.transcribe#InternalFailureException":
1921
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1922
- case "LimitExceededException":
1923
- case "com.amazonaws.transcribe#LimitExceededException":
1924
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1925
- case "NotFoundException":
1926
- case "com.amazonaws.transcribe#NotFoundException":
1927
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1928
- default:
1929
- const parsedBody = parsedOutput.body;
1930
- return throwDefaultError({
1931
- output,
1932
- parsedBody,
1933
- errorCode,
1934
- });
1935
- }
1936
- };
1937
788
  export const de_UpdateVocabularyFilterCommand = async (output, context) => {
1938
789
  if (output.statusCode >= 300) {
1939
- return de_UpdateVocabularyFilterCommandError(output, context);
790
+ return de_CommandError(output, context);
1940
791
  }
1941
792
  const data = await parseBody(output.body, context);
1942
793
  let contents = {};
@@ -1947,7 +798,7 @@ export const de_UpdateVocabularyFilterCommand = async (output, context) => {
1947
798
  };
1948
799
  return response;
1949
800
  };
1950
- const de_UpdateVocabularyFilterCommandError = async (output, context) => {
801
+ const de_CommandError = async (output, context) => {
1951
802
  const parsedOutput = {
1952
803
  ...output,
1953
804
  body: await parseErrorBody(output.body, context),
@@ -1957,6 +808,9 @@ const de_UpdateVocabularyFilterCommandError = async (output, context) => {
1957
808
  case "BadRequestException":
1958
809
  case "com.amazonaws.transcribe#BadRequestException":
1959
810
  throw await de_BadRequestExceptionRes(parsedOutput, context);
811
+ case "ConflictException":
812
+ case "com.amazonaws.transcribe#ConflictException":
813
+ throw await de_ConflictExceptionRes(parsedOutput, context);
1960
814
  case "InternalFailureException":
1961
815
  case "com.amazonaws.transcribe#InternalFailureException":
1962
816
  throw await de_InternalFailureExceptionRes(parsedOutput, context);