@aws-sdk/client-datasync 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 +96 -1394
  2. package/dist-es/protocols/Aws_json1_1.js +65 -1363
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -456,7 +456,7 @@ export const se_UpdateTaskExecutionCommand = async (input, context) => {
456
456
  };
457
457
  export const de_AddStorageSystemCommand = async (output, context) => {
458
458
  if (output.statusCode >= 300) {
459
- return de_AddStorageSystemCommandError(output, context);
459
+ return de_CommandError(output, context);
460
460
  }
461
461
  const data = await parseBody(output.body, context);
462
462
  let contents = {};
@@ -467,31 +467,9 @@ export const de_AddStorageSystemCommand = async (output, context) => {
467
467
  };
468
468
  return response;
469
469
  };
470
- const de_AddStorageSystemCommandError = async (output, context) => {
471
- const parsedOutput = {
472
- ...output,
473
- body: await parseErrorBody(output.body, context),
474
- };
475
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
476
- switch (errorCode) {
477
- case "InternalException":
478
- case "com.amazonaws.datasync#InternalException":
479
- throw await de_InternalExceptionRes(parsedOutput, context);
480
- case "InvalidRequestException":
481
- case "com.amazonaws.datasync#InvalidRequestException":
482
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
483
- default:
484
- const parsedBody = parsedOutput.body;
485
- return throwDefaultError({
486
- output,
487
- parsedBody,
488
- errorCode,
489
- });
490
- }
491
- };
492
470
  export const de_CancelTaskExecutionCommand = async (output, context) => {
493
471
  if (output.statusCode >= 300) {
494
- return de_CancelTaskExecutionCommandError(output, context);
472
+ return de_CommandError(output, context);
495
473
  }
496
474
  const data = await parseBody(output.body, context);
497
475
  let contents = {};
@@ -502,31 +480,9 @@ export const de_CancelTaskExecutionCommand = async (output, context) => {
502
480
  };
503
481
  return response;
504
482
  };
505
- const de_CancelTaskExecutionCommandError = async (output, context) => {
506
- const parsedOutput = {
507
- ...output,
508
- body: await parseErrorBody(output.body, context),
509
- };
510
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
511
- switch (errorCode) {
512
- case "InternalException":
513
- case "com.amazonaws.datasync#InternalException":
514
- throw await de_InternalExceptionRes(parsedOutput, context);
515
- case "InvalidRequestException":
516
- case "com.amazonaws.datasync#InvalidRequestException":
517
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
518
- default:
519
- const parsedBody = parsedOutput.body;
520
- return throwDefaultError({
521
- output,
522
- parsedBody,
523
- errorCode,
524
- });
525
- }
526
- };
527
483
  export const de_CreateAgentCommand = async (output, context) => {
528
484
  if (output.statusCode >= 300) {
529
- return de_CreateAgentCommandError(output, context);
485
+ return de_CommandError(output, context);
530
486
  }
531
487
  const data = await parseBody(output.body, context);
532
488
  let contents = {};
@@ -537,31 +493,9 @@ export const de_CreateAgentCommand = async (output, context) => {
537
493
  };
538
494
  return response;
539
495
  };
540
- const de_CreateAgentCommandError = async (output, context) => {
541
- const parsedOutput = {
542
- ...output,
543
- body: await parseErrorBody(output.body, context),
544
- };
545
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
546
- switch (errorCode) {
547
- case "InternalException":
548
- case "com.amazonaws.datasync#InternalException":
549
- throw await de_InternalExceptionRes(parsedOutput, context);
550
- case "InvalidRequestException":
551
- case "com.amazonaws.datasync#InvalidRequestException":
552
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
553
- default:
554
- const parsedBody = parsedOutput.body;
555
- return throwDefaultError({
556
- output,
557
- parsedBody,
558
- errorCode,
559
- });
560
- }
561
- };
562
496
  export const de_CreateLocationAzureBlobCommand = async (output, context) => {
563
497
  if (output.statusCode >= 300) {
564
- return de_CreateLocationAzureBlobCommandError(output, context);
498
+ return de_CommandError(output, context);
565
499
  }
566
500
  const data = await parseBody(output.body, context);
567
501
  let contents = {};
@@ -572,31 +506,9 @@ export const de_CreateLocationAzureBlobCommand = async (output, context) => {
572
506
  };
573
507
  return response;
574
508
  };
575
- const de_CreateLocationAzureBlobCommandError = async (output, context) => {
576
- const parsedOutput = {
577
- ...output,
578
- body: await parseErrorBody(output.body, context),
579
- };
580
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
581
- switch (errorCode) {
582
- case "InternalException":
583
- case "com.amazonaws.datasync#InternalException":
584
- throw await de_InternalExceptionRes(parsedOutput, context);
585
- case "InvalidRequestException":
586
- case "com.amazonaws.datasync#InvalidRequestException":
587
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
588
- default:
589
- const parsedBody = parsedOutput.body;
590
- return throwDefaultError({
591
- output,
592
- parsedBody,
593
- errorCode,
594
- });
595
- }
596
- };
597
509
  export const de_CreateLocationEfsCommand = async (output, context) => {
598
510
  if (output.statusCode >= 300) {
599
- return de_CreateLocationEfsCommandError(output, context);
511
+ return de_CommandError(output, context);
600
512
  }
601
513
  const data = await parseBody(output.body, context);
602
514
  let contents = {};
@@ -607,31 +519,9 @@ export const de_CreateLocationEfsCommand = async (output, context) => {
607
519
  };
608
520
  return response;
609
521
  };
610
- const de_CreateLocationEfsCommandError = async (output, context) => {
611
- const parsedOutput = {
612
- ...output,
613
- body: await parseErrorBody(output.body, context),
614
- };
615
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
616
- switch (errorCode) {
617
- case "InternalException":
618
- case "com.amazonaws.datasync#InternalException":
619
- throw await de_InternalExceptionRes(parsedOutput, context);
620
- case "InvalidRequestException":
621
- case "com.amazonaws.datasync#InvalidRequestException":
622
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
623
- default:
624
- const parsedBody = parsedOutput.body;
625
- return throwDefaultError({
626
- output,
627
- parsedBody,
628
- errorCode,
629
- });
630
- }
631
- };
632
522
  export const de_CreateLocationFsxLustreCommand = async (output, context) => {
633
523
  if (output.statusCode >= 300) {
634
- return de_CreateLocationFsxLustreCommandError(output, context);
524
+ return de_CommandError(output, context);
635
525
  }
636
526
  const data = await parseBody(output.body, context);
637
527
  let contents = {};
@@ -642,31 +532,9 @@ export const de_CreateLocationFsxLustreCommand = async (output, context) => {
642
532
  };
643
533
  return response;
644
534
  };
645
- const de_CreateLocationFsxLustreCommandError = async (output, context) => {
646
- const parsedOutput = {
647
- ...output,
648
- body: await parseErrorBody(output.body, context),
649
- };
650
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
651
- switch (errorCode) {
652
- case "InternalException":
653
- case "com.amazonaws.datasync#InternalException":
654
- throw await de_InternalExceptionRes(parsedOutput, context);
655
- case "InvalidRequestException":
656
- case "com.amazonaws.datasync#InvalidRequestException":
657
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
658
- default:
659
- const parsedBody = parsedOutput.body;
660
- return throwDefaultError({
661
- output,
662
- parsedBody,
663
- errorCode,
664
- });
665
- }
666
- };
667
535
  export const de_CreateLocationFsxOntapCommand = async (output, context) => {
668
536
  if (output.statusCode >= 300) {
669
- return de_CreateLocationFsxOntapCommandError(output, context);
537
+ return de_CommandError(output, context);
670
538
  }
671
539
  const data = await parseBody(output.body, context);
672
540
  let contents = {};
@@ -677,31 +545,9 @@ export const de_CreateLocationFsxOntapCommand = async (output, context) => {
677
545
  };
678
546
  return response;
679
547
  };
680
- const de_CreateLocationFsxOntapCommandError = async (output, context) => {
681
- const parsedOutput = {
682
- ...output,
683
- body: await parseErrorBody(output.body, context),
684
- };
685
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
686
- switch (errorCode) {
687
- case "InternalException":
688
- case "com.amazonaws.datasync#InternalException":
689
- throw await de_InternalExceptionRes(parsedOutput, context);
690
- case "InvalidRequestException":
691
- case "com.amazonaws.datasync#InvalidRequestException":
692
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
693
- default:
694
- const parsedBody = parsedOutput.body;
695
- return throwDefaultError({
696
- output,
697
- parsedBody,
698
- errorCode,
699
- });
700
- }
701
- };
702
548
  export const de_CreateLocationFsxOpenZfsCommand = async (output, context) => {
703
549
  if (output.statusCode >= 300) {
704
- return de_CreateLocationFsxOpenZfsCommandError(output, context);
550
+ return de_CommandError(output, context);
705
551
  }
706
552
  const data = await parseBody(output.body, context);
707
553
  let contents = {};
@@ -712,31 +558,9 @@ export const de_CreateLocationFsxOpenZfsCommand = async (output, context) => {
712
558
  };
713
559
  return response;
714
560
  };
715
- const de_CreateLocationFsxOpenZfsCommandError = async (output, context) => {
716
- const parsedOutput = {
717
- ...output,
718
- body: await parseErrorBody(output.body, context),
719
- };
720
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
721
- switch (errorCode) {
722
- case "InternalException":
723
- case "com.amazonaws.datasync#InternalException":
724
- throw await de_InternalExceptionRes(parsedOutput, context);
725
- case "InvalidRequestException":
726
- case "com.amazonaws.datasync#InvalidRequestException":
727
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
728
- default:
729
- const parsedBody = parsedOutput.body;
730
- return throwDefaultError({
731
- output,
732
- parsedBody,
733
- errorCode,
734
- });
735
- }
736
- };
737
561
  export const de_CreateLocationFsxWindowsCommand = async (output, context) => {
738
562
  if (output.statusCode >= 300) {
739
- return de_CreateLocationFsxWindowsCommandError(output, context);
563
+ return de_CommandError(output, context);
740
564
  }
741
565
  const data = await parseBody(output.body, context);
742
566
  let contents = {};
@@ -747,31 +571,9 @@ export const de_CreateLocationFsxWindowsCommand = async (output, context) => {
747
571
  };
748
572
  return response;
749
573
  };
750
- const de_CreateLocationFsxWindowsCommandError = async (output, context) => {
751
- const parsedOutput = {
752
- ...output,
753
- body: await parseErrorBody(output.body, context),
754
- };
755
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
756
- switch (errorCode) {
757
- case "InternalException":
758
- case "com.amazonaws.datasync#InternalException":
759
- throw await de_InternalExceptionRes(parsedOutput, context);
760
- case "InvalidRequestException":
761
- case "com.amazonaws.datasync#InvalidRequestException":
762
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
763
- default:
764
- const parsedBody = parsedOutput.body;
765
- return throwDefaultError({
766
- output,
767
- parsedBody,
768
- errorCode,
769
- });
770
- }
771
- };
772
574
  export const de_CreateLocationHdfsCommand = async (output, context) => {
773
575
  if (output.statusCode >= 300) {
774
- return de_CreateLocationHdfsCommandError(output, context);
576
+ return de_CommandError(output, context);
775
577
  }
776
578
  const data = await parseBody(output.body, context);
777
579
  let contents = {};
@@ -782,31 +584,9 @@ export const de_CreateLocationHdfsCommand = async (output, context) => {
782
584
  };
783
585
  return response;
784
586
  };
785
- const de_CreateLocationHdfsCommandError = async (output, context) => {
786
- const parsedOutput = {
787
- ...output,
788
- body: await parseErrorBody(output.body, context),
789
- };
790
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
791
- switch (errorCode) {
792
- case "InternalException":
793
- case "com.amazonaws.datasync#InternalException":
794
- throw await de_InternalExceptionRes(parsedOutput, context);
795
- case "InvalidRequestException":
796
- case "com.amazonaws.datasync#InvalidRequestException":
797
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
798
- default:
799
- const parsedBody = parsedOutput.body;
800
- return throwDefaultError({
801
- output,
802
- parsedBody,
803
- errorCode,
804
- });
805
- }
806
- };
807
587
  export const de_CreateLocationNfsCommand = async (output, context) => {
808
588
  if (output.statusCode >= 300) {
809
- return de_CreateLocationNfsCommandError(output, context);
589
+ return de_CommandError(output, context);
810
590
  }
811
591
  const data = await parseBody(output.body, context);
812
592
  let contents = {};
@@ -817,31 +597,9 @@ export const de_CreateLocationNfsCommand = async (output, context) => {
817
597
  };
818
598
  return response;
819
599
  };
820
- const de_CreateLocationNfsCommandError = async (output, context) => {
821
- const parsedOutput = {
822
- ...output,
823
- body: await parseErrorBody(output.body, context),
824
- };
825
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
826
- switch (errorCode) {
827
- case "InternalException":
828
- case "com.amazonaws.datasync#InternalException":
829
- throw await de_InternalExceptionRes(parsedOutput, context);
830
- case "InvalidRequestException":
831
- case "com.amazonaws.datasync#InvalidRequestException":
832
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
833
- default:
834
- const parsedBody = parsedOutput.body;
835
- return throwDefaultError({
836
- output,
837
- parsedBody,
838
- errorCode,
839
- });
840
- }
841
- };
842
600
  export const de_CreateLocationObjectStorageCommand = async (output, context) => {
843
601
  if (output.statusCode >= 300) {
844
- return de_CreateLocationObjectStorageCommandError(output, context);
602
+ return de_CommandError(output, context);
845
603
  }
846
604
  const data = await parseBody(output.body, context);
847
605
  let contents = {};
@@ -852,31 +610,9 @@ export const de_CreateLocationObjectStorageCommand = async (output, context) =>
852
610
  };
853
611
  return response;
854
612
  };
855
- const de_CreateLocationObjectStorageCommandError = 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 "InternalException":
863
- case "com.amazonaws.datasync#InternalException":
864
- throw await de_InternalExceptionRes(parsedOutput, context);
865
- case "InvalidRequestException":
866
- case "com.amazonaws.datasync#InvalidRequestException":
867
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
868
- default:
869
- const parsedBody = parsedOutput.body;
870
- return throwDefaultError({
871
- output,
872
- parsedBody,
873
- errorCode,
874
- });
875
- }
876
- };
877
613
  export const de_CreateLocationS3Command = async (output, context) => {
878
614
  if (output.statusCode >= 300) {
879
- return de_CreateLocationS3CommandError(output, context);
615
+ return de_CommandError(output, context);
880
616
  }
881
617
  const data = await parseBody(output.body, context);
882
618
  let contents = {};
@@ -887,31 +623,9 @@ export const de_CreateLocationS3Command = async (output, context) => {
887
623
  };
888
624
  return response;
889
625
  };
890
- const de_CreateLocationS3CommandError = async (output, context) => {
891
- const parsedOutput = {
892
- ...output,
893
- body: await parseErrorBody(output.body, context),
894
- };
895
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
896
- switch (errorCode) {
897
- case "InternalException":
898
- case "com.amazonaws.datasync#InternalException":
899
- throw await de_InternalExceptionRes(parsedOutput, context);
900
- case "InvalidRequestException":
901
- case "com.amazonaws.datasync#InvalidRequestException":
902
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
903
- default:
904
- const parsedBody = parsedOutput.body;
905
- return throwDefaultError({
906
- output,
907
- parsedBody,
908
- errorCode,
909
- });
910
- }
911
- };
912
626
  export const de_CreateLocationSmbCommand = async (output, context) => {
913
627
  if (output.statusCode >= 300) {
914
- return de_CreateLocationSmbCommandError(output, context);
628
+ return de_CommandError(output, context);
915
629
  }
916
630
  const data = await parseBody(output.body, context);
917
631
  let contents = {};
@@ -922,31 +636,9 @@ export const de_CreateLocationSmbCommand = async (output, context) => {
922
636
  };
923
637
  return response;
924
638
  };
925
- const de_CreateLocationSmbCommandError = async (output, context) => {
926
- const parsedOutput = {
927
- ...output,
928
- body: await parseErrorBody(output.body, context),
929
- };
930
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
931
- switch (errorCode) {
932
- case "InternalException":
933
- case "com.amazonaws.datasync#InternalException":
934
- throw await de_InternalExceptionRes(parsedOutput, context);
935
- case "InvalidRequestException":
936
- case "com.amazonaws.datasync#InvalidRequestException":
937
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
938
- default:
939
- const parsedBody = parsedOutput.body;
940
- return throwDefaultError({
941
- output,
942
- parsedBody,
943
- errorCode,
944
- });
945
- }
946
- };
947
639
  export const de_CreateTaskCommand = async (output, context) => {
948
640
  if (output.statusCode >= 300) {
949
- return de_CreateTaskCommandError(output, context);
641
+ return de_CommandError(output, context);
950
642
  }
951
643
  const data = await parseBody(output.body, context);
952
644
  let contents = {};
@@ -957,31 +649,9 @@ export const de_CreateTaskCommand = async (output, context) => {
957
649
  };
958
650
  return response;
959
651
  };
960
- const de_CreateTaskCommandError = async (output, context) => {
961
- const parsedOutput = {
962
- ...output,
963
- body: await parseErrorBody(output.body, context),
964
- };
965
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
966
- switch (errorCode) {
967
- case "InternalException":
968
- case "com.amazonaws.datasync#InternalException":
969
- throw await de_InternalExceptionRes(parsedOutput, context);
970
- case "InvalidRequestException":
971
- case "com.amazonaws.datasync#InvalidRequestException":
972
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
973
- default:
974
- const parsedBody = parsedOutput.body;
975
- return throwDefaultError({
976
- output,
977
- parsedBody,
978
- errorCode,
979
- });
980
- }
981
- };
982
652
  export const de_DeleteAgentCommand = async (output, context) => {
983
653
  if (output.statusCode >= 300) {
984
- return de_DeleteAgentCommandError(output, context);
654
+ return de_CommandError(output, context);
985
655
  }
986
656
  const data = await parseBody(output.body, context);
987
657
  let contents = {};
@@ -992,31 +662,9 @@ export const de_DeleteAgentCommand = async (output, context) => {
992
662
  };
993
663
  return response;
994
664
  };
995
- const de_DeleteAgentCommandError = async (output, context) => {
996
- const parsedOutput = {
997
- ...output,
998
- body: await parseErrorBody(output.body, context),
999
- };
1000
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1001
- switch (errorCode) {
1002
- case "InternalException":
1003
- case "com.amazonaws.datasync#InternalException":
1004
- throw await de_InternalExceptionRes(parsedOutput, context);
1005
- case "InvalidRequestException":
1006
- case "com.amazonaws.datasync#InvalidRequestException":
1007
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1008
- default:
1009
- const parsedBody = parsedOutput.body;
1010
- return throwDefaultError({
1011
- output,
1012
- parsedBody,
1013
- errorCode,
1014
- });
1015
- }
1016
- };
1017
665
  export const de_DeleteLocationCommand = async (output, context) => {
1018
666
  if (output.statusCode >= 300) {
1019
- return de_DeleteLocationCommandError(output, context);
667
+ return de_CommandError(output, context);
1020
668
  }
1021
669
  const data = await parseBody(output.body, context);
1022
670
  let contents = {};
@@ -1027,31 +675,9 @@ export const de_DeleteLocationCommand = async (output, context) => {
1027
675
  };
1028
676
  return response;
1029
677
  };
1030
- const de_DeleteLocationCommandError = async (output, context) => {
1031
- const parsedOutput = {
1032
- ...output,
1033
- body: await parseErrorBody(output.body, context),
1034
- };
1035
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1036
- switch (errorCode) {
1037
- case "InternalException":
1038
- case "com.amazonaws.datasync#InternalException":
1039
- throw await de_InternalExceptionRes(parsedOutput, context);
1040
- case "InvalidRequestException":
1041
- case "com.amazonaws.datasync#InvalidRequestException":
1042
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1043
- default:
1044
- const parsedBody = parsedOutput.body;
1045
- return throwDefaultError({
1046
- output,
1047
- parsedBody,
1048
- errorCode,
1049
- });
1050
- }
1051
- };
1052
678
  export const de_DeleteTaskCommand = async (output, context) => {
1053
679
  if (output.statusCode >= 300) {
1054
- return de_DeleteTaskCommandError(output, context);
680
+ return de_CommandError(output, context);
1055
681
  }
1056
682
  const data = await parseBody(output.body, context);
1057
683
  let contents = {};
@@ -1062,31 +688,9 @@ export const de_DeleteTaskCommand = async (output, context) => {
1062
688
  };
1063
689
  return response;
1064
690
  };
1065
- const de_DeleteTaskCommandError = async (output, context) => {
1066
- const parsedOutput = {
1067
- ...output,
1068
- body: await parseErrorBody(output.body, context),
1069
- };
1070
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1071
- switch (errorCode) {
1072
- case "InternalException":
1073
- case "com.amazonaws.datasync#InternalException":
1074
- throw await de_InternalExceptionRes(parsedOutput, context);
1075
- case "InvalidRequestException":
1076
- case "com.amazonaws.datasync#InvalidRequestException":
1077
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1078
- default:
1079
- const parsedBody = parsedOutput.body;
1080
- return throwDefaultError({
1081
- output,
1082
- parsedBody,
1083
- errorCode,
1084
- });
1085
- }
1086
- };
1087
691
  export const de_DescribeAgentCommand = async (output, context) => {
1088
692
  if (output.statusCode >= 300) {
1089
- return de_DescribeAgentCommandError(output, context);
693
+ return de_CommandError(output, context);
1090
694
  }
1091
695
  const data = await parseBody(output.body, context);
1092
696
  let contents = {};
@@ -1097,31 +701,9 @@ export const de_DescribeAgentCommand = async (output, context) => {
1097
701
  };
1098
702
  return response;
1099
703
  };
1100
- const de_DescribeAgentCommandError = async (output, context) => {
1101
- const parsedOutput = {
1102
- ...output,
1103
- body: await parseErrorBody(output.body, context),
1104
- };
1105
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1106
- switch (errorCode) {
1107
- case "InternalException":
1108
- case "com.amazonaws.datasync#InternalException":
1109
- throw await de_InternalExceptionRes(parsedOutput, context);
1110
- case "InvalidRequestException":
1111
- case "com.amazonaws.datasync#InvalidRequestException":
1112
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1113
- default:
1114
- const parsedBody = parsedOutput.body;
1115
- return throwDefaultError({
1116
- output,
1117
- parsedBody,
1118
- errorCode,
1119
- });
1120
- }
1121
- };
1122
704
  export const de_DescribeDiscoveryJobCommand = async (output, context) => {
1123
705
  if (output.statusCode >= 300) {
1124
- return de_DescribeDiscoveryJobCommandError(output, context);
706
+ return de_CommandError(output, context);
1125
707
  }
1126
708
  const data = await parseBody(output.body, context);
1127
709
  let contents = {};
@@ -1132,31 +714,9 @@ export const de_DescribeDiscoveryJobCommand = async (output, context) => {
1132
714
  };
1133
715
  return response;
1134
716
  };
1135
- const de_DescribeDiscoveryJobCommandError = async (output, context) => {
1136
- const parsedOutput = {
1137
- ...output,
1138
- body: await parseErrorBody(output.body, context),
1139
- };
1140
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1141
- switch (errorCode) {
1142
- case "InternalException":
1143
- case "com.amazonaws.datasync#InternalException":
1144
- throw await de_InternalExceptionRes(parsedOutput, context);
1145
- case "InvalidRequestException":
1146
- case "com.amazonaws.datasync#InvalidRequestException":
1147
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1148
- default:
1149
- const parsedBody = parsedOutput.body;
1150
- return throwDefaultError({
1151
- output,
1152
- parsedBody,
1153
- errorCode,
1154
- });
1155
- }
1156
- };
1157
717
  export const de_DescribeLocationAzureBlobCommand = async (output, context) => {
1158
718
  if (output.statusCode >= 300) {
1159
- return de_DescribeLocationAzureBlobCommandError(output, context);
719
+ return de_CommandError(output, context);
1160
720
  }
1161
721
  const data = await parseBody(output.body, context);
1162
722
  let contents = {};
@@ -1167,31 +727,9 @@ export const de_DescribeLocationAzureBlobCommand = async (output, context) => {
1167
727
  };
1168
728
  return response;
1169
729
  };
1170
- const de_DescribeLocationAzureBlobCommandError = async (output, context) => {
1171
- const parsedOutput = {
1172
- ...output,
1173
- body: await parseErrorBody(output.body, context),
1174
- };
1175
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1176
- switch (errorCode) {
1177
- case "InternalException":
1178
- case "com.amazonaws.datasync#InternalException":
1179
- throw await de_InternalExceptionRes(parsedOutput, context);
1180
- case "InvalidRequestException":
1181
- case "com.amazonaws.datasync#InvalidRequestException":
1182
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1183
- default:
1184
- const parsedBody = parsedOutput.body;
1185
- return throwDefaultError({
1186
- output,
1187
- parsedBody,
1188
- errorCode,
1189
- });
1190
- }
1191
- };
1192
730
  export const de_DescribeLocationEfsCommand = async (output, context) => {
1193
731
  if (output.statusCode >= 300) {
1194
- return de_DescribeLocationEfsCommandError(output, context);
732
+ return de_CommandError(output, context);
1195
733
  }
1196
734
  const data = await parseBody(output.body, context);
1197
735
  let contents = {};
@@ -1202,31 +740,9 @@ export const de_DescribeLocationEfsCommand = async (output, context) => {
1202
740
  };
1203
741
  return response;
1204
742
  };
1205
- const de_DescribeLocationEfsCommandError = async (output, context) => {
1206
- const parsedOutput = {
1207
- ...output,
1208
- body: await parseErrorBody(output.body, context),
1209
- };
1210
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1211
- switch (errorCode) {
1212
- case "InternalException":
1213
- case "com.amazonaws.datasync#InternalException":
1214
- throw await de_InternalExceptionRes(parsedOutput, context);
1215
- case "InvalidRequestException":
1216
- case "com.amazonaws.datasync#InvalidRequestException":
1217
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1218
- default:
1219
- const parsedBody = parsedOutput.body;
1220
- return throwDefaultError({
1221
- output,
1222
- parsedBody,
1223
- errorCode,
1224
- });
1225
- }
1226
- };
1227
743
  export const de_DescribeLocationFsxLustreCommand = async (output, context) => {
1228
744
  if (output.statusCode >= 300) {
1229
- return de_DescribeLocationFsxLustreCommandError(output, context);
745
+ return de_CommandError(output, context);
1230
746
  }
1231
747
  const data = await parseBody(output.body, context);
1232
748
  let contents = {};
@@ -1237,31 +753,9 @@ export const de_DescribeLocationFsxLustreCommand = async (output, context) => {
1237
753
  };
1238
754
  return response;
1239
755
  };
1240
- const de_DescribeLocationFsxLustreCommandError = async (output, context) => {
1241
- const parsedOutput = {
1242
- ...output,
1243
- body: await parseErrorBody(output.body, context),
1244
- };
1245
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1246
- switch (errorCode) {
1247
- case "InternalException":
1248
- case "com.amazonaws.datasync#InternalException":
1249
- throw await de_InternalExceptionRes(parsedOutput, context);
1250
- case "InvalidRequestException":
1251
- case "com.amazonaws.datasync#InvalidRequestException":
1252
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1253
- default:
1254
- const parsedBody = parsedOutput.body;
1255
- return throwDefaultError({
1256
- output,
1257
- parsedBody,
1258
- errorCode,
1259
- });
1260
- }
1261
- };
1262
756
  export const de_DescribeLocationFsxOntapCommand = async (output, context) => {
1263
757
  if (output.statusCode >= 300) {
1264
- return de_DescribeLocationFsxOntapCommandError(output, context);
758
+ return de_CommandError(output, context);
1265
759
  }
1266
760
  const data = await parseBody(output.body, context);
1267
761
  let contents = {};
@@ -1272,31 +766,9 @@ export const de_DescribeLocationFsxOntapCommand = async (output, context) => {
1272
766
  };
1273
767
  return response;
1274
768
  };
1275
- const de_DescribeLocationFsxOntapCommandError = async (output, context) => {
1276
- const parsedOutput = {
1277
- ...output,
1278
- body: await parseErrorBody(output.body, context),
1279
- };
1280
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1281
- switch (errorCode) {
1282
- case "InternalException":
1283
- case "com.amazonaws.datasync#InternalException":
1284
- throw await de_InternalExceptionRes(parsedOutput, context);
1285
- case "InvalidRequestException":
1286
- case "com.amazonaws.datasync#InvalidRequestException":
1287
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1288
- default:
1289
- const parsedBody = parsedOutput.body;
1290
- return throwDefaultError({
1291
- output,
1292
- parsedBody,
1293
- errorCode,
1294
- });
1295
- }
1296
- };
1297
769
  export const de_DescribeLocationFsxOpenZfsCommand = async (output, context) => {
1298
770
  if (output.statusCode >= 300) {
1299
- return de_DescribeLocationFsxOpenZfsCommandError(output, context);
771
+ return de_CommandError(output, context);
1300
772
  }
1301
773
  const data = await parseBody(output.body, context);
1302
774
  let contents = {};
@@ -1307,31 +779,9 @@ export const de_DescribeLocationFsxOpenZfsCommand = async (output, context) => {
1307
779
  };
1308
780
  return response;
1309
781
  };
1310
- const de_DescribeLocationFsxOpenZfsCommandError = async (output, context) => {
1311
- const parsedOutput = {
1312
- ...output,
1313
- body: await parseErrorBody(output.body, context),
1314
- };
1315
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1316
- switch (errorCode) {
1317
- case "InternalException":
1318
- case "com.amazonaws.datasync#InternalException":
1319
- throw await de_InternalExceptionRes(parsedOutput, context);
1320
- case "InvalidRequestException":
1321
- case "com.amazonaws.datasync#InvalidRequestException":
1322
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1323
- default:
1324
- const parsedBody = parsedOutput.body;
1325
- return throwDefaultError({
1326
- output,
1327
- parsedBody,
1328
- errorCode,
1329
- });
1330
- }
1331
- };
1332
782
  export const de_DescribeLocationFsxWindowsCommand = async (output, context) => {
1333
783
  if (output.statusCode >= 300) {
1334
- return de_DescribeLocationFsxWindowsCommandError(output, context);
784
+ return de_CommandError(output, context);
1335
785
  }
1336
786
  const data = await parseBody(output.body, context);
1337
787
  let contents = {};
@@ -1342,31 +792,9 @@ export const de_DescribeLocationFsxWindowsCommand = async (output, context) => {
1342
792
  };
1343
793
  return response;
1344
794
  };
1345
- const de_DescribeLocationFsxWindowsCommandError = async (output, context) => {
1346
- const parsedOutput = {
1347
- ...output,
1348
- body: await parseErrorBody(output.body, context),
1349
- };
1350
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1351
- switch (errorCode) {
1352
- case "InternalException":
1353
- case "com.amazonaws.datasync#InternalException":
1354
- throw await de_InternalExceptionRes(parsedOutput, context);
1355
- case "InvalidRequestException":
1356
- case "com.amazonaws.datasync#InvalidRequestException":
1357
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1358
- default:
1359
- const parsedBody = parsedOutput.body;
1360
- return throwDefaultError({
1361
- output,
1362
- parsedBody,
1363
- errorCode,
1364
- });
1365
- }
1366
- };
1367
795
  export const de_DescribeLocationHdfsCommand = async (output, context) => {
1368
796
  if (output.statusCode >= 300) {
1369
- return de_DescribeLocationHdfsCommandError(output, context);
797
+ return de_CommandError(output, context);
1370
798
  }
1371
799
  const data = await parseBody(output.body, context);
1372
800
  let contents = {};
@@ -1377,31 +805,9 @@ export const de_DescribeLocationHdfsCommand = async (output, context) => {
1377
805
  };
1378
806
  return response;
1379
807
  };
1380
- const de_DescribeLocationHdfsCommandError = async (output, context) => {
1381
- const parsedOutput = {
1382
- ...output,
1383
- body: await parseErrorBody(output.body, context),
1384
- };
1385
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1386
- switch (errorCode) {
1387
- case "InternalException":
1388
- case "com.amazonaws.datasync#InternalException":
1389
- throw await de_InternalExceptionRes(parsedOutput, context);
1390
- case "InvalidRequestException":
1391
- case "com.amazonaws.datasync#InvalidRequestException":
1392
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1393
- default:
1394
- const parsedBody = parsedOutput.body;
1395
- return throwDefaultError({
1396
- output,
1397
- parsedBody,
1398
- errorCode,
1399
- });
1400
- }
1401
- };
1402
808
  export const de_DescribeLocationNfsCommand = async (output, context) => {
1403
809
  if (output.statusCode >= 300) {
1404
- return de_DescribeLocationNfsCommandError(output, context);
810
+ return de_CommandError(output, context);
1405
811
  }
1406
812
  const data = await parseBody(output.body, context);
1407
813
  let contents = {};
@@ -1412,31 +818,9 @@ export const de_DescribeLocationNfsCommand = async (output, context) => {
1412
818
  };
1413
819
  return response;
1414
820
  };
1415
- const de_DescribeLocationNfsCommandError = async (output, context) => {
1416
- const parsedOutput = {
1417
- ...output,
1418
- body: await parseErrorBody(output.body, context),
1419
- };
1420
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1421
- switch (errorCode) {
1422
- case "InternalException":
1423
- case "com.amazonaws.datasync#InternalException":
1424
- throw await de_InternalExceptionRes(parsedOutput, context);
1425
- case "InvalidRequestException":
1426
- case "com.amazonaws.datasync#InvalidRequestException":
1427
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1428
- default:
1429
- const parsedBody = parsedOutput.body;
1430
- return throwDefaultError({
1431
- output,
1432
- parsedBody,
1433
- errorCode,
1434
- });
1435
- }
1436
- };
1437
821
  export const de_DescribeLocationObjectStorageCommand = async (output, context) => {
1438
822
  if (output.statusCode >= 300) {
1439
- return de_DescribeLocationObjectStorageCommandError(output, context);
823
+ return de_CommandError(output, context);
1440
824
  }
1441
825
  const data = await parseBody(output.body, context);
1442
826
  let contents = {};
@@ -1447,31 +831,9 @@ export const de_DescribeLocationObjectStorageCommand = async (output, context) =
1447
831
  };
1448
832
  return response;
1449
833
  };
1450
- const de_DescribeLocationObjectStorageCommandError = async (output, context) => {
1451
- const parsedOutput = {
1452
- ...output,
1453
- body: await parseErrorBody(output.body, context),
1454
- };
1455
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1456
- switch (errorCode) {
1457
- case "InternalException":
1458
- case "com.amazonaws.datasync#InternalException":
1459
- throw await de_InternalExceptionRes(parsedOutput, context);
1460
- case "InvalidRequestException":
1461
- case "com.amazonaws.datasync#InvalidRequestException":
1462
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1463
- default:
1464
- const parsedBody = parsedOutput.body;
1465
- return throwDefaultError({
1466
- output,
1467
- parsedBody,
1468
- errorCode,
1469
- });
1470
- }
1471
- };
1472
834
  export const de_DescribeLocationS3Command = async (output, context) => {
1473
835
  if (output.statusCode >= 300) {
1474
- return de_DescribeLocationS3CommandError(output, context);
836
+ return de_CommandError(output, context);
1475
837
  }
1476
838
  const data = await parseBody(output.body, context);
1477
839
  let contents = {};
@@ -1482,31 +844,9 @@ export const de_DescribeLocationS3Command = async (output, context) => {
1482
844
  };
1483
845
  return response;
1484
846
  };
1485
- const de_DescribeLocationS3CommandError = async (output, context) => {
1486
- const parsedOutput = {
1487
- ...output,
1488
- body: await parseErrorBody(output.body, context),
1489
- };
1490
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1491
- switch (errorCode) {
1492
- case "InternalException":
1493
- case "com.amazonaws.datasync#InternalException":
1494
- throw await de_InternalExceptionRes(parsedOutput, context);
1495
- case "InvalidRequestException":
1496
- case "com.amazonaws.datasync#InvalidRequestException":
1497
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1498
- default:
1499
- const parsedBody = parsedOutput.body;
1500
- return throwDefaultError({
1501
- output,
1502
- parsedBody,
1503
- errorCode,
1504
- });
1505
- }
1506
- };
1507
847
  export const de_DescribeLocationSmbCommand = async (output, context) => {
1508
848
  if (output.statusCode >= 300) {
1509
- return de_DescribeLocationSmbCommandError(output, context);
849
+ return de_CommandError(output, context);
1510
850
  }
1511
851
  const data = await parseBody(output.body, context);
1512
852
  let contents = {};
@@ -1517,31 +857,9 @@ export const de_DescribeLocationSmbCommand = async (output, context) => {
1517
857
  };
1518
858
  return response;
1519
859
  };
1520
- const de_DescribeLocationSmbCommandError = async (output, context) => {
1521
- const parsedOutput = {
1522
- ...output,
1523
- body: await parseErrorBody(output.body, context),
1524
- };
1525
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1526
- switch (errorCode) {
1527
- case "InternalException":
1528
- case "com.amazonaws.datasync#InternalException":
1529
- throw await de_InternalExceptionRes(parsedOutput, context);
1530
- case "InvalidRequestException":
1531
- case "com.amazonaws.datasync#InvalidRequestException":
1532
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1533
- default:
1534
- const parsedBody = parsedOutput.body;
1535
- return throwDefaultError({
1536
- output,
1537
- parsedBody,
1538
- errorCode,
1539
- });
1540
- }
1541
- };
1542
860
  export const de_DescribeStorageSystemCommand = async (output, context) => {
1543
861
  if (output.statusCode >= 300) {
1544
- return de_DescribeStorageSystemCommandError(output, context);
862
+ return de_CommandError(output, context);
1545
863
  }
1546
864
  const data = await parseBody(output.body, context);
1547
865
  let contents = {};
@@ -1552,31 +870,9 @@ export const de_DescribeStorageSystemCommand = async (output, context) => {
1552
870
  };
1553
871
  return response;
1554
872
  };
1555
- const de_DescribeStorageSystemCommandError = async (output, context) => {
1556
- const parsedOutput = {
1557
- ...output,
1558
- body: await parseErrorBody(output.body, context),
1559
- };
1560
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1561
- switch (errorCode) {
1562
- case "InternalException":
1563
- case "com.amazonaws.datasync#InternalException":
1564
- throw await de_InternalExceptionRes(parsedOutput, context);
1565
- case "InvalidRequestException":
1566
- case "com.amazonaws.datasync#InvalidRequestException":
1567
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1568
- default:
1569
- const parsedBody = parsedOutput.body;
1570
- return throwDefaultError({
1571
- output,
1572
- parsedBody,
1573
- errorCode,
1574
- });
1575
- }
1576
- };
1577
873
  export const de_DescribeStorageSystemResourceMetricsCommand = async (output, context) => {
1578
874
  if (output.statusCode >= 300) {
1579
- return de_DescribeStorageSystemResourceMetricsCommandError(output, context);
875
+ return de_CommandError(output, context);
1580
876
  }
1581
877
  const data = await parseBody(output.body, context);
1582
878
  let contents = {};
@@ -1587,31 +883,9 @@ export const de_DescribeStorageSystemResourceMetricsCommand = async (output, con
1587
883
  };
1588
884
  return response;
1589
885
  };
1590
- const de_DescribeStorageSystemResourceMetricsCommandError = async (output, context) => {
1591
- const parsedOutput = {
1592
- ...output,
1593
- body: await parseErrorBody(output.body, context),
1594
- };
1595
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1596
- switch (errorCode) {
1597
- case "InternalException":
1598
- case "com.amazonaws.datasync#InternalException":
1599
- throw await de_InternalExceptionRes(parsedOutput, context);
1600
- case "InvalidRequestException":
1601
- case "com.amazonaws.datasync#InvalidRequestException":
1602
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1603
- default:
1604
- const parsedBody = parsedOutput.body;
1605
- return throwDefaultError({
1606
- output,
1607
- parsedBody,
1608
- errorCode,
1609
- });
1610
- }
1611
- };
1612
886
  export const de_DescribeStorageSystemResourcesCommand = async (output, context) => {
1613
887
  if (output.statusCode >= 300) {
1614
- return de_DescribeStorageSystemResourcesCommandError(output, context);
888
+ return de_CommandError(output, context);
1615
889
  }
1616
890
  const data = await parseBody(output.body, context);
1617
891
  let contents = {};
@@ -1622,31 +896,9 @@ export const de_DescribeStorageSystemResourcesCommand = async (output, context)
1622
896
  };
1623
897
  return response;
1624
898
  };
1625
- const de_DescribeStorageSystemResourcesCommandError = async (output, context) => {
1626
- const parsedOutput = {
1627
- ...output,
1628
- body: await parseErrorBody(output.body, context),
1629
- };
1630
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1631
- switch (errorCode) {
1632
- case "InternalException":
1633
- case "com.amazonaws.datasync#InternalException":
1634
- throw await de_InternalExceptionRes(parsedOutput, context);
1635
- case "InvalidRequestException":
1636
- case "com.amazonaws.datasync#InvalidRequestException":
1637
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1638
- default:
1639
- const parsedBody = parsedOutput.body;
1640
- return throwDefaultError({
1641
- output,
1642
- parsedBody,
1643
- errorCode,
1644
- });
1645
- }
1646
- };
1647
899
  export const de_DescribeTaskCommand = async (output, context) => {
1648
900
  if (output.statusCode >= 300) {
1649
- return de_DescribeTaskCommandError(output, context);
901
+ return de_CommandError(output, context);
1650
902
  }
1651
903
  const data = await parseBody(output.body, context);
1652
904
  let contents = {};
@@ -1657,31 +909,9 @@ export const de_DescribeTaskCommand = async (output, context) => {
1657
909
  };
1658
910
  return response;
1659
911
  };
1660
- const de_DescribeTaskCommandError = async (output, context) => {
1661
- const parsedOutput = {
1662
- ...output,
1663
- body: await parseErrorBody(output.body, context),
1664
- };
1665
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1666
- switch (errorCode) {
1667
- case "InternalException":
1668
- case "com.amazonaws.datasync#InternalException":
1669
- throw await de_InternalExceptionRes(parsedOutput, context);
1670
- case "InvalidRequestException":
1671
- case "com.amazonaws.datasync#InvalidRequestException":
1672
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1673
- default:
1674
- const parsedBody = parsedOutput.body;
1675
- return throwDefaultError({
1676
- output,
1677
- parsedBody,
1678
- errorCode,
1679
- });
1680
- }
1681
- };
1682
912
  export const de_DescribeTaskExecutionCommand = async (output, context) => {
1683
913
  if (output.statusCode >= 300) {
1684
- return de_DescribeTaskExecutionCommandError(output, context);
914
+ return de_CommandError(output, context);
1685
915
  }
1686
916
  const data = await parseBody(output.body, context);
1687
917
  let contents = {};
@@ -1692,31 +922,9 @@ export const de_DescribeTaskExecutionCommand = async (output, context) => {
1692
922
  };
1693
923
  return response;
1694
924
  };
1695
- const de_DescribeTaskExecutionCommandError = async (output, context) => {
1696
- const parsedOutput = {
1697
- ...output,
1698
- body: await parseErrorBody(output.body, context),
1699
- };
1700
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1701
- switch (errorCode) {
1702
- case "InternalException":
1703
- case "com.amazonaws.datasync#InternalException":
1704
- throw await de_InternalExceptionRes(parsedOutput, context);
1705
- case "InvalidRequestException":
1706
- case "com.amazonaws.datasync#InvalidRequestException":
1707
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1708
- default:
1709
- const parsedBody = parsedOutput.body;
1710
- return throwDefaultError({
1711
- output,
1712
- parsedBody,
1713
- errorCode,
1714
- });
1715
- }
1716
- };
1717
925
  export const de_GenerateRecommendationsCommand = async (output, context) => {
1718
926
  if (output.statusCode >= 300) {
1719
- return de_GenerateRecommendationsCommandError(output, context);
927
+ return de_CommandError(output, context);
1720
928
  }
1721
929
  const data = await parseBody(output.body, context);
1722
930
  let contents = {};
@@ -1727,31 +935,9 @@ export const de_GenerateRecommendationsCommand = async (output, context) => {
1727
935
  };
1728
936
  return response;
1729
937
  };
1730
- const de_GenerateRecommendationsCommandError = 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 "InternalException":
1738
- case "com.amazonaws.datasync#InternalException":
1739
- throw await de_InternalExceptionRes(parsedOutput, context);
1740
- case "InvalidRequestException":
1741
- case "com.amazonaws.datasync#InvalidRequestException":
1742
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1743
- default:
1744
- const parsedBody = parsedOutput.body;
1745
- return throwDefaultError({
1746
- output,
1747
- parsedBody,
1748
- errorCode,
1749
- });
1750
- }
1751
- };
1752
938
  export const de_ListAgentsCommand = async (output, context) => {
1753
939
  if (output.statusCode >= 300) {
1754
- return de_ListAgentsCommandError(output, context);
940
+ return de_CommandError(output, context);
1755
941
  }
1756
942
  const data = await parseBody(output.body, context);
1757
943
  let contents = {};
@@ -1762,31 +948,9 @@ export const de_ListAgentsCommand = async (output, context) => {
1762
948
  };
1763
949
  return response;
1764
950
  };
1765
- const de_ListAgentsCommandError = async (output, context) => {
1766
- const parsedOutput = {
1767
- ...output,
1768
- body: await parseErrorBody(output.body, context),
1769
- };
1770
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1771
- switch (errorCode) {
1772
- case "InternalException":
1773
- case "com.amazonaws.datasync#InternalException":
1774
- throw await de_InternalExceptionRes(parsedOutput, context);
1775
- case "InvalidRequestException":
1776
- case "com.amazonaws.datasync#InvalidRequestException":
1777
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1778
- default:
1779
- const parsedBody = parsedOutput.body;
1780
- return throwDefaultError({
1781
- output,
1782
- parsedBody,
1783
- errorCode,
1784
- });
1785
- }
1786
- };
1787
951
  export const de_ListDiscoveryJobsCommand = async (output, context) => {
1788
952
  if (output.statusCode >= 300) {
1789
- return de_ListDiscoveryJobsCommandError(output, context);
953
+ return de_CommandError(output, context);
1790
954
  }
1791
955
  const data = await parseBody(output.body, context);
1792
956
  let contents = {};
@@ -1797,31 +961,9 @@ export const de_ListDiscoveryJobsCommand = async (output, context) => {
1797
961
  };
1798
962
  return response;
1799
963
  };
1800
- const de_ListDiscoveryJobsCommandError = async (output, context) => {
1801
- const parsedOutput = {
1802
- ...output,
1803
- body: await parseErrorBody(output.body, context),
1804
- };
1805
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1806
- switch (errorCode) {
1807
- case "InternalException":
1808
- case "com.amazonaws.datasync#InternalException":
1809
- throw await de_InternalExceptionRes(parsedOutput, context);
1810
- case "InvalidRequestException":
1811
- case "com.amazonaws.datasync#InvalidRequestException":
1812
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1813
- default:
1814
- const parsedBody = parsedOutput.body;
1815
- return throwDefaultError({
1816
- output,
1817
- parsedBody,
1818
- errorCode,
1819
- });
1820
- }
1821
- };
1822
964
  export const de_ListLocationsCommand = async (output, context) => {
1823
965
  if (output.statusCode >= 300) {
1824
- return de_ListLocationsCommandError(output, context);
966
+ return de_CommandError(output, context);
1825
967
  }
1826
968
  const data = await parseBody(output.body, context);
1827
969
  let contents = {};
@@ -1832,31 +974,9 @@ export const de_ListLocationsCommand = async (output, context) => {
1832
974
  };
1833
975
  return response;
1834
976
  };
1835
- const de_ListLocationsCommandError = async (output, context) => {
1836
- const parsedOutput = {
1837
- ...output,
1838
- body: await parseErrorBody(output.body, context),
1839
- };
1840
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1841
- switch (errorCode) {
1842
- case "InternalException":
1843
- case "com.amazonaws.datasync#InternalException":
1844
- throw await de_InternalExceptionRes(parsedOutput, context);
1845
- case "InvalidRequestException":
1846
- case "com.amazonaws.datasync#InvalidRequestException":
1847
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1848
- default:
1849
- const parsedBody = parsedOutput.body;
1850
- return throwDefaultError({
1851
- output,
1852
- parsedBody,
1853
- errorCode,
1854
- });
1855
- }
1856
- };
1857
977
  export const de_ListStorageSystemsCommand = async (output, context) => {
1858
978
  if (output.statusCode >= 300) {
1859
- return de_ListStorageSystemsCommandError(output, context);
979
+ return de_CommandError(output, context);
1860
980
  }
1861
981
  const data = await parseBody(output.body, context);
1862
982
  let contents = {};
@@ -1867,31 +987,9 @@ export const de_ListStorageSystemsCommand = async (output, context) => {
1867
987
  };
1868
988
  return response;
1869
989
  };
1870
- const de_ListStorageSystemsCommandError = async (output, context) => {
1871
- const parsedOutput = {
1872
- ...output,
1873
- body: await parseErrorBody(output.body, context),
1874
- };
1875
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1876
- switch (errorCode) {
1877
- case "InternalException":
1878
- case "com.amazonaws.datasync#InternalException":
1879
- throw await de_InternalExceptionRes(parsedOutput, context);
1880
- case "InvalidRequestException":
1881
- case "com.amazonaws.datasync#InvalidRequestException":
1882
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1883
- default:
1884
- const parsedBody = parsedOutput.body;
1885
- return throwDefaultError({
1886
- output,
1887
- parsedBody,
1888
- errorCode,
1889
- });
1890
- }
1891
- };
1892
990
  export const de_ListTagsForResourceCommand = async (output, context) => {
1893
991
  if (output.statusCode >= 300) {
1894
- return de_ListTagsForResourceCommandError(output, context);
992
+ return de_CommandError(output, context);
1895
993
  }
1896
994
  const data = await parseBody(output.body, context);
1897
995
  let contents = {};
@@ -1902,31 +1000,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
1902
1000
  };
1903
1001
  return response;
1904
1002
  };
1905
- const de_ListTagsForResourceCommandError = async (output, context) => {
1906
- const parsedOutput = {
1907
- ...output,
1908
- body: await parseErrorBody(output.body, context),
1909
- };
1910
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1911
- switch (errorCode) {
1912
- case "InternalException":
1913
- case "com.amazonaws.datasync#InternalException":
1914
- throw await de_InternalExceptionRes(parsedOutput, context);
1915
- case "InvalidRequestException":
1916
- case "com.amazonaws.datasync#InvalidRequestException":
1917
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1918
- default:
1919
- const parsedBody = parsedOutput.body;
1920
- return throwDefaultError({
1921
- output,
1922
- parsedBody,
1923
- errorCode,
1924
- });
1925
- }
1926
- };
1927
1003
  export const de_ListTaskExecutionsCommand = async (output, context) => {
1928
1004
  if (output.statusCode >= 300) {
1929
- return de_ListTaskExecutionsCommandError(output, context);
1005
+ return de_CommandError(output, context);
1930
1006
  }
1931
1007
  const data = await parseBody(output.body, context);
1932
1008
  let contents = {};
@@ -1937,31 +1013,9 @@ export const de_ListTaskExecutionsCommand = async (output, context) => {
1937
1013
  };
1938
1014
  return response;
1939
1015
  };
1940
- const de_ListTaskExecutionsCommandError = async (output, context) => {
1941
- const parsedOutput = {
1942
- ...output,
1943
- body: await parseErrorBody(output.body, context),
1944
- };
1945
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1946
- switch (errorCode) {
1947
- case "InternalException":
1948
- case "com.amazonaws.datasync#InternalException":
1949
- throw await de_InternalExceptionRes(parsedOutput, context);
1950
- case "InvalidRequestException":
1951
- case "com.amazonaws.datasync#InvalidRequestException":
1952
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1953
- default:
1954
- const parsedBody = parsedOutput.body;
1955
- return throwDefaultError({
1956
- output,
1957
- parsedBody,
1958
- errorCode,
1959
- });
1960
- }
1961
- };
1962
1016
  export const de_ListTasksCommand = async (output, context) => {
1963
1017
  if (output.statusCode >= 300) {
1964
- return de_ListTasksCommandError(output, context);
1018
+ return de_CommandError(output, context);
1965
1019
  }
1966
1020
  const data = await parseBody(output.body, context);
1967
1021
  let contents = {};
@@ -1972,31 +1026,9 @@ export const de_ListTasksCommand = async (output, context) => {
1972
1026
  };
1973
1027
  return response;
1974
1028
  };
1975
- const de_ListTasksCommandError = async (output, context) => {
1976
- const parsedOutput = {
1977
- ...output,
1978
- body: await parseErrorBody(output.body, context),
1979
- };
1980
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1981
- switch (errorCode) {
1982
- case "InternalException":
1983
- case "com.amazonaws.datasync#InternalException":
1984
- throw await de_InternalExceptionRes(parsedOutput, context);
1985
- case "InvalidRequestException":
1986
- case "com.amazonaws.datasync#InvalidRequestException":
1987
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1988
- default:
1989
- const parsedBody = parsedOutput.body;
1990
- return throwDefaultError({
1991
- output,
1992
- parsedBody,
1993
- errorCode,
1994
- });
1995
- }
1996
- };
1997
1029
  export const de_RemoveStorageSystemCommand = async (output, context) => {
1998
1030
  if (output.statusCode >= 300) {
1999
- return de_RemoveStorageSystemCommandError(output, context);
1031
+ return de_CommandError(output, context);
2000
1032
  }
2001
1033
  const data = await parseBody(output.body, context);
2002
1034
  let contents = {};
@@ -2007,31 +1039,9 @@ export const de_RemoveStorageSystemCommand = async (output, context) => {
2007
1039
  };
2008
1040
  return response;
2009
1041
  };
2010
- const de_RemoveStorageSystemCommandError = async (output, context) => {
2011
- const parsedOutput = {
2012
- ...output,
2013
- body: await parseErrorBody(output.body, context),
2014
- };
2015
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2016
- switch (errorCode) {
2017
- case "InternalException":
2018
- case "com.amazonaws.datasync#InternalException":
2019
- throw await de_InternalExceptionRes(parsedOutput, context);
2020
- case "InvalidRequestException":
2021
- case "com.amazonaws.datasync#InvalidRequestException":
2022
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2023
- default:
2024
- const parsedBody = parsedOutput.body;
2025
- return throwDefaultError({
2026
- output,
2027
- parsedBody,
2028
- errorCode,
2029
- });
2030
- }
2031
- };
2032
1042
  export const de_StartDiscoveryJobCommand = async (output, context) => {
2033
1043
  if (output.statusCode >= 300) {
2034
- return de_StartDiscoveryJobCommandError(output, context);
1044
+ return de_CommandError(output, context);
2035
1045
  }
2036
1046
  const data = await parseBody(output.body, context);
2037
1047
  let contents = {};
@@ -2042,66 +1052,22 @@ export const de_StartDiscoveryJobCommand = async (output, context) => {
2042
1052
  };
2043
1053
  return response;
2044
1054
  };
2045
- const de_StartDiscoveryJobCommandError = async (output, context) => {
2046
- const parsedOutput = {
2047
- ...output,
2048
- body: await parseErrorBody(output.body, context),
2049
- };
2050
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2051
- switch (errorCode) {
2052
- case "InternalException":
2053
- case "com.amazonaws.datasync#InternalException":
2054
- throw await de_InternalExceptionRes(parsedOutput, context);
2055
- case "InvalidRequestException":
2056
- case "com.amazonaws.datasync#InvalidRequestException":
2057
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2058
- default:
2059
- const parsedBody = parsedOutput.body;
2060
- return throwDefaultError({
2061
- output,
2062
- parsedBody,
2063
- errorCode,
2064
- });
2065
- }
2066
- };
2067
1055
  export const de_StartTaskExecutionCommand = async (output, context) => {
2068
1056
  if (output.statusCode >= 300) {
2069
- return de_StartTaskExecutionCommandError(output, context);
1057
+ return de_CommandError(output, context);
2070
1058
  }
2071
1059
  const data = await parseBody(output.body, context);
2072
1060
  let contents = {};
2073
1061
  contents = _json(data);
2074
1062
  const response = {
2075
- $metadata: deserializeMetadata(output),
2076
- ...contents,
2077
- };
2078
- return response;
2079
- };
2080
- const de_StartTaskExecutionCommandError = async (output, context) => {
2081
- const parsedOutput = {
2082
- ...output,
2083
- body: await parseErrorBody(output.body, context),
2084
- };
2085
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2086
- switch (errorCode) {
2087
- case "InternalException":
2088
- case "com.amazonaws.datasync#InternalException":
2089
- throw await de_InternalExceptionRes(parsedOutput, context);
2090
- case "InvalidRequestException":
2091
- case "com.amazonaws.datasync#InvalidRequestException":
2092
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2093
- default:
2094
- const parsedBody = parsedOutput.body;
2095
- return throwDefaultError({
2096
- output,
2097
- parsedBody,
2098
- errorCode,
2099
- });
2100
- }
1063
+ $metadata: deserializeMetadata(output),
1064
+ ...contents,
1065
+ };
1066
+ return response;
2101
1067
  };
2102
1068
  export const de_StopDiscoveryJobCommand = async (output, context) => {
2103
1069
  if (output.statusCode >= 300) {
2104
- return de_StopDiscoveryJobCommandError(output, context);
1070
+ return de_CommandError(output, context);
2105
1071
  }
2106
1072
  const data = await parseBody(output.body, context);
2107
1073
  let contents = {};
@@ -2112,31 +1078,9 @@ export const de_StopDiscoveryJobCommand = async (output, context) => {
2112
1078
  };
2113
1079
  return response;
2114
1080
  };
2115
- const de_StopDiscoveryJobCommandError = async (output, context) => {
2116
- const parsedOutput = {
2117
- ...output,
2118
- body: await parseErrorBody(output.body, context),
2119
- };
2120
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2121
- switch (errorCode) {
2122
- case "InternalException":
2123
- case "com.amazonaws.datasync#InternalException":
2124
- throw await de_InternalExceptionRes(parsedOutput, context);
2125
- case "InvalidRequestException":
2126
- case "com.amazonaws.datasync#InvalidRequestException":
2127
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2128
- default:
2129
- const parsedBody = parsedOutput.body;
2130
- return throwDefaultError({
2131
- output,
2132
- parsedBody,
2133
- errorCode,
2134
- });
2135
- }
2136
- };
2137
1081
  export const de_TagResourceCommand = async (output, context) => {
2138
1082
  if (output.statusCode >= 300) {
2139
- return de_TagResourceCommandError(output, context);
1083
+ return de_CommandError(output, context);
2140
1084
  }
2141
1085
  const data = await parseBody(output.body, context);
2142
1086
  let contents = {};
@@ -2147,31 +1091,9 @@ export const de_TagResourceCommand = async (output, context) => {
2147
1091
  };
2148
1092
  return response;
2149
1093
  };
2150
- const de_TagResourceCommandError = async (output, context) => {
2151
- const parsedOutput = {
2152
- ...output,
2153
- body: await parseErrorBody(output.body, context),
2154
- };
2155
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2156
- switch (errorCode) {
2157
- case "InternalException":
2158
- case "com.amazonaws.datasync#InternalException":
2159
- throw await de_InternalExceptionRes(parsedOutput, context);
2160
- case "InvalidRequestException":
2161
- case "com.amazonaws.datasync#InvalidRequestException":
2162
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2163
- default:
2164
- const parsedBody = parsedOutput.body;
2165
- return throwDefaultError({
2166
- output,
2167
- parsedBody,
2168
- errorCode,
2169
- });
2170
- }
2171
- };
2172
1094
  export const de_UntagResourceCommand = async (output, context) => {
2173
1095
  if (output.statusCode >= 300) {
2174
- return de_UntagResourceCommandError(output, context);
1096
+ return de_CommandError(output, context);
2175
1097
  }
2176
1098
  const data = await parseBody(output.body, context);
2177
1099
  let contents = {};
@@ -2182,31 +1104,9 @@ export const de_UntagResourceCommand = async (output, context) => {
2182
1104
  };
2183
1105
  return response;
2184
1106
  };
2185
- const de_UntagResourceCommandError = async (output, context) => {
2186
- const parsedOutput = {
2187
- ...output,
2188
- body: await parseErrorBody(output.body, context),
2189
- };
2190
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2191
- switch (errorCode) {
2192
- case "InternalException":
2193
- case "com.amazonaws.datasync#InternalException":
2194
- throw await de_InternalExceptionRes(parsedOutput, context);
2195
- case "InvalidRequestException":
2196
- case "com.amazonaws.datasync#InvalidRequestException":
2197
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2198
- default:
2199
- const parsedBody = parsedOutput.body;
2200
- return throwDefaultError({
2201
- output,
2202
- parsedBody,
2203
- errorCode,
2204
- });
2205
- }
2206
- };
2207
1107
  export const de_UpdateAgentCommand = async (output, context) => {
2208
1108
  if (output.statusCode >= 300) {
2209
- return de_UpdateAgentCommandError(output, context);
1109
+ return de_CommandError(output, context);
2210
1110
  }
2211
1111
  const data = await parseBody(output.body, context);
2212
1112
  let contents = {};
@@ -2217,31 +1117,9 @@ export const de_UpdateAgentCommand = async (output, context) => {
2217
1117
  };
2218
1118
  return response;
2219
1119
  };
2220
- const de_UpdateAgentCommandError = async (output, context) => {
2221
- const parsedOutput = {
2222
- ...output,
2223
- body: await parseErrorBody(output.body, context),
2224
- };
2225
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2226
- switch (errorCode) {
2227
- case "InternalException":
2228
- case "com.amazonaws.datasync#InternalException":
2229
- throw await de_InternalExceptionRes(parsedOutput, context);
2230
- case "InvalidRequestException":
2231
- case "com.amazonaws.datasync#InvalidRequestException":
2232
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2233
- default:
2234
- const parsedBody = parsedOutput.body;
2235
- return throwDefaultError({
2236
- output,
2237
- parsedBody,
2238
- errorCode,
2239
- });
2240
- }
2241
- };
2242
1120
  export const de_UpdateDiscoveryJobCommand = async (output, context) => {
2243
1121
  if (output.statusCode >= 300) {
2244
- return de_UpdateDiscoveryJobCommandError(output, context);
1122
+ return de_CommandError(output, context);
2245
1123
  }
2246
1124
  const data = await parseBody(output.body, context);
2247
1125
  let contents = {};
@@ -2252,31 +1130,9 @@ export const de_UpdateDiscoveryJobCommand = async (output, context) => {
2252
1130
  };
2253
1131
  return response;
2254
1132
  };
2255
- const de_UpdateDiscoveryJobCommandError = async (output, context) => {
2256
- const parsedOutput = {
2257
- ...output,
2258
- body: await parseErrorBody(output.body, context),
2259
- };
2260
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2261
- switch (errorCode) {
2262
- case "InternalException":
2263
- case "com.amazonaws.datasync#InternalException":
2264
- throw await de_InternalExceptionRes(parsedOutput, context);
2265
- case "InvalidRequestException":
2266
- case "com.amazonaws.datasync#InvalidRequestException":
2267
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2268
- default:
2269
- const parsedBody = parsedOutput.body;
2270
- return throwDefaultError({
2271
- output,
2272
- parsedBody,
2273
- errorCode,
2274
- });
2275
- }
2276
- };
2277
1133
  export const de_UpdateLocationAzureBlobCommand = async (output, context) => {
2278
1134
  if (output.statusCode >= 300) {
2279
- return de_UpdateLocationAzureBlobCommandError(output, context);
1135
+ return de_CommandError(output, context);
2280
1136
  }
2281
1137
  const data = await parseBody(output.body, context);
2282
1138
  let contents = {};
@@ -2287,31 +1143,9 @@ export const de_UpdateLocationAzureBlobCommand = async (output, context) => {
2287
1143
  };
2288
1144
  return response;
2289
1145
  };
2290
- const de_UpdateLocationAzureBlobCommandError = async (output, context) => {
2291
- const parsedOutput = {
2292
- ...output,
2293
- body: await parseErrorBody(output.body, context),
2294
- };
2295
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2296
- switch (errorCode) {
2297
- case "InternalException":
2298
- case "com.amazonaws.datasync#InternalException":
2299
- throw await de_InternalExceptionRes(parsedOutput, context);
2300
- case "InvalidRequestException":
2301
- case "com.amazonaws.datasync#InvalidRequestException":
2302
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2303
- default:
2304
- const parsedBody = parsedOutput.body;
2305
- return throwDefaultError({
2306
- output,
2307
- parsedBody,
2308
- errorCode,
2309
- });
2310
- }
2311
- };
2312
1146
  export const de_UpdateLocationHdfsCommand = async (output, context) => {
2313
1147
  if (output.statusCode >= 300) {
2314
- return de_UpdateLocationHdfsCommandError(output, context);
1148
+ return de_CommandError(output, context);
2315
1149
  }
2316
1150
  const data = await parseBody(output.body, context);
2317
1151
  let contents = {};
@@ -2322,31 +1156,9 @@ export const de_UpdateLocationHdfsCommand = async (output, context) => {
2322
1156
  };
2323
1157
  return response;
2324
1158
  };
2325
- const de_UpdateLocationHdfsCommandError = async (output, context) => {
2326
- const parsedOutput = {
2327
- ...output,
2328
- body: await parseErrorBody(output.body, context),
2329
- };
2330
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2331
- switch (errorCode) {
2332
- case "InternalException":
2333
- case "com.amazonaws.datasync#InternalException":
2334
- throw await de_InternalExceptionRes(parsedOutput, context);
2335
- case "InvalidRequestException":
2336
- case "com.amazonaws.datasync#InvalidRequestException":
2337
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2338
- default:
2339
- const parsedBody = parsedOutput.body;
2340
- return throwDefaultError({
2341
- output,
2342
- parsedBody,
2343
- errorCode,
2344
- });
2345
- }
2346
- };
2347
1159
  export const de_UpdateLocationNfsCommand = async (output, context) => {
2348
1160
  if (output.statusCode >= 300) {
2349
- return de_UpdateLocationNfsCommandError(output, context);
1161
+ return de_CommandError(output, context);
2350
1162
  }
2351
1163
  const data = await parseBody(output.body, context);
2352
1164
  let contents = {};
@@ -2357,31 +1169,9 @@ export const de_UpdateLocationNfsCommand = async (output, context) => {
2357
1169
  };
2358
1170
  return response;
2359
1171
  };
2360
- const de_UpdateLocationNfsCommandError = async (output, context) => {
2361
- const parsedOutput = {
2362
- ...output,
2363
- body: await parseErrorBody(output.body, context),
2364
- };
2365
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2366
- switch (errorCode) {
2367
- case "InternalException":
2368
- case "com.amazonaws.datasync#InternalException":
2369
- throw await de_InternalExceptionRes(parsedOutput, context);
2370
- case "InvalidRequestException":
2371
- case "com.amazonaws.datasync#InvalidRequestException":
2372
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2373
- default:
2374
- const parsedBody = parsedOutput.body;
2375
- return throwDefaultError({
2376
- output,
2377
- parsedBody,
2378
- errorCode,
2379
- });
2380
- }
2381
- };
2382
1172
  export const de_UpdateLocationObjectStorageCommand = async (output, context) => {
2383
1173
  if (output.statusCode >= 300) {
2384
- return de_UpdateLocationObjectStorageCommandError(output, context);
1174
+ return de_CommandError(output, context);
2385
1175
  }
2386
1176
  const data = await parseBody(output.body, context);
2387
1177
  let contents = {};
@@ -2392,31 +1182,9 @@ export const de_UpdateLocationObjectStorageCommand = async (output, context) =>
2392
1182
  };
2393
1183
  return response;
2394
1184
  };
2395
- const de_UpdateLocationObjectStorageCommandError = async (output, context) => {
2396
- const parsedOutput = {
2397
- ...output,
2398
- body: await parseErrorBody(output.body, context),
2399
- };
2400
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2401
- switch (errorCode) {
2402
- case "InternalException":
2403
- case "com.amazonaws.datasync#InternalException":
2404
- throw await de_InternalExceptionRes(parsedOutput, context);
2405
- case "InvalidRequestException":
2406
- case "com.amazonaws.datasync#InvalidRequestException":
2407
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2408
- default:
2409
- const parsedBody = parsedOutput.body;
2410
- return throwDefaultError({
2411
- output,
2412
- parsedBody,
2413
- errorCode,
2414
- });
2415
- }
2416
- };
2417
1185
  export const de_UpdateLocationSmbCommand = async (output, context) => {
2418
1186
  if (output.statusCode >= 300) {
2419
- return de_UpdateLocationSmbCommandError(output, context);
1187
+ return de_CommandError(output, context);
2420
1188
  }
2421
1189
  const data = await parseBody(output.body, context);
2422
1190
  let contents = {};
@@ -2427,31 +1195,9 @@ export const de_UpdateLocationSmbCommand = async (output, context) => {
2427
1195
  };
2428
1196
  return response;
2429
1197
  };
2430
- const de_UpdateLocationSmbCommandError = async (output, context) => {
2431
- const parsedOutput = {
2432
- ...output,
2433
- body: await parseErrorBody(output.body, context),
2434
- };
2435
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2436
- switch (errorCode) {
2437
- case "InternalException":
2438
- case "com.amazonaws.datasync#InternalException":
2439
- throw await de_InternalExceptionRes(parsedOutput, context);
2440
- case "InvalidRequestException":
2441
- case "com.amazonaws.datasync#InvalidRequestException":
2442
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2443
- default:
2444
- const parsedBody = parsedOutput.body;
2445
- return throwDefaultError({
2446
- output,
2447
- parsedBody,
2448
- errorCode,
2449
- });
2450
- }
2451
- };
2452
1198
  export const de_UpdateStorageSystemCommand = async (output, context) => {
2453
1199
  if (output.statusCode >= 300) {
2454
- return de_UpdateStorageSystemCommandError(output, context);
1200
+ return de_CommandError(output, context);
2455
1201
  }
2456
1202
  const data = await parseBody(output.body, context);
2457
1203
  let contents = {};
@@ -2462,31 +1208,9 @@ export const de_UpdateStorageSystemCommand = async (output, context) => {
2462
1208
  };
2463
1209
  return response;
2464
1210
  };
2465
- const de_UpdateStorageSystemCommandError = async (output, context) => {
2466
- const parsedOutput = {
2467
- ...output,
2468
- body: await parseErrorBody(output.body, context),
2469
- };
2470
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2471
- switch (errorCode) {
2472
- case "InternalException":
2473
- case "com.amazonaws.datasync#InternalException":
2474
- throw await de_InternalExceptionRes(parsedOutput, context);
2475
- case "InvalidRequestException":
2476
- case "com.amazonaws.datasync#InvalidRequestException":
2477
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2478
- default:
2479
- const parsedBody = parsedOutput.body;
2480
- return throwDefaultError({
2481
- output,
2482
- parsedBody,
2483
- errorCode,
2484
- });
2485
- }
2486
- };
2487
1211
  export const de_UpdateTaskCommand = async (output, context) => {
2488
1212
  if (output.statusCode >= 300) {
2489
- return de_UpdateTaskCommandError(output, context);
1213
+ return de_CommandError(output, context);
2490
1214
  }
2491
1215
  const data = await parseBody(output.body, context);
2492
1216
  let contents = {};
@@ -2497,31 +1221,9 @@ export const de_UpdateTaskCommand = async (output, context) => {
2497
1221
  };
2498
1222
  return response;
2499
1223
  };
2500
- const de_UpdateTaskCommandError = async (output, context) => {
2501
- const parsedOutput = {
2502
- ...output,
2503
- body: await parseErrorBody(output.body, context),
2504
- };
2505
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2506
- switch (errorCode) {
2507
- case "InternalException":
2508
- case "com.amazonaws.datasync#InternalException":
2509
- throw await de_InternalExceptionRes(parsedOutput, context);
2510
- case "InvalidRequestException":
2511
- case "com.amazonaws.datasync#InvalidRequestException":
2512
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2513
- default:
2514
- const parsedBody = parsedOutput.body;
2515
- return throwDefaultError({
2516
- output,
2517
- parsedBody,
2518
- errorCode,
2519
- });
2520
- }
2521
- };
2522
1224
  export const de_UpdateTaskExecutionCommand = async (output, context) => {
2523
1225
  if (output.statusCode >= 300) {
2524
- return de_UpdateTaskExecutionCommandError(output, context);
1226
+ return de_CommandError(output, context);
2525
1227
  }
2526
1228
  const data = await parseBody(output.body, context);
2527
1229
  let contents = {};
@@ -2532,7 +1234,7 @@ export const de_UpdateTaskExecutionCommand = async (output, context) => {
2532
1234
  };
2533
1235
  return response;
2534
1236
  };
2535
- const de_UpdateTaskExecutionCommandError = async (output, context) => {
1237
+ const de_CommandError = async (output, context) => {
2536
1238
  const parsedOutput = {
2537
1239
  ...output,
2538
1240
  body: await parseErrorBody(output.body, context),