@aws-sdk/client-qconnect 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 +74 -1111
  2. package/dist-es/protocols/Aws_restJson1.js +90 -1127
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -592,7 +592,7 @@ export const se_UpdateQuickResponseCommand = async (input, context) => {
592
592
  };
593
593
  export const de_CreateAssistantCommand = async (output, context) => {
594
594
  if (output.statusCode !== 200 && output.statusCode >= 300) {
595
- return de_CreateAssistantCommandError(output, context);
595
+ return de_CommandError(output, context);
596
596
  }
597
597
  const contents = map({
598
598
  $metadata: deserializeMetadata(output),
@@ -604,37 +604,9 @@ export const de_CreateAssistantCommand = async (output, context) => {
604
604
  Object.assign(contents, doc);
605
605
  return contents;
606
606
  };
607
- const de_CreateAssistantCommandError = async (output, context) => {
608
- const parsedOutput = {
609
- ...output,
610
- body: await parseErrorBody(output.body, context),
611
- };
612
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
613
- switch (errorCode) {
614
- case "AccessDeniedException":
615
- case "com.amazonaws.qconnect#AccessDeniedException":
616
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
617
- case "ConflictException":
618
- case "com.amazonaws.qconnect#ConflictException":
619
- throw await de_ConflictExceptionRes(parsedOutput, context);
620
- case "ServiceQuotaExceededException":
621
- case "com.amazonaws.qconnect#ServiceQuotaExceededException":
622
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
623
- case "ValidationException":
624
- case "com.amazonaws.qconnect#ValidationException":
625
- throw await de_ValidationExceptionRes(parsedOutput, context);
626
- default:
627
- const parsedBody = parsedOutput.body;
628
- return throwDefaultError({
629
- output,
630
- parsedBody,
631
- errorCode,
632
- });
633
- }
634
- };
635
607
  export const de_CreateAssistantAssociationCommand = async (output, context) => {
636
608
  if (output.statusCode !== 200 && output.statusCode >= 300) {
637
- return de_CreateAssistantAssociationCommandError(output, context);
609
+ return de_CommandError(output, context);
638
610
  }
639
611
  const contents = map({
640
612
  $metadata: deserializeMetadata(output),
@@ -646,40 +618,9 @@ export const de_CreateAssistantAssociationCommand = async (output, context) => {
646
618
  Object.assign(contents, doc);
647
619
  return contents;
648
620
  };
649
- const de_CreateAssistantAssociationCommandError = async (output, context) => {
650
- const parsedOutput = {
651
- ...output,
652
- body: await parseErrorBody(output.body, context),
653
- };
654
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
655
- switch (errorCode) {
656
- case "AccessDeniedException":
657
- case "com.amazonaws.qconnect#AccessDeniedException":
658
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
659
- case "ConflictException":
660
- case "com.amazonaws.qconnect#ConflictException":
661
- throw await de_ConflictExceptionRes(parsedOutput, context);
662
- case "ResourceNotFoundException":
663
- case "com.amazonaws.qconnect#ResourceNotFoundException":
664
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
665
- case "ServiceQuotaExceededException":
666
- case "com.amazonaws.qconnect#ServiceQuotaExceededException":
667
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
668
- case "ValidationException":
669
- case "com.amazonaws.qconnect#ValidationException":
670
- throw await de_ValidationExceptionRes(parsedOutput, context);
671
- default:
672
- const parsedBody = parsedOutput.body;
673
- return throwDefaultError({
674
- output,
675
- parsedBody,
676
- errorCode,
677
- });
678
- }
679
- };
680
621
  export const de_CreateContentCommand = async (output, context) => {
681
622
  if (output.statusCode !== 200 && output.statusCode >= 300) {
682
- return de_CreateContentCommandError(output, context);
623
+ return de_CommandError(output, context);
683
624
  }
684
625
  const contents = map({
685
626
  $metadata: deserializeMetadata(output),
@@ -691,40 +632,9 @@ export const de_CreateContentCommand = async (output, context) => {
691
632
  Object.assign(contents, doc);
692
633
  return contents;
693
634
  };
694
- const de_CreateContentCommandError = async (output, context) => {
695
- const parsedOutput = {
696
- ...output,
697
- body: await parseErrorBody(output.body, context),
698
- };
699
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
700
- switch (errorCode) {
701
- case "AccessDeniedException":
702
- case "com.amazonaws.qconnect#AccessDeniedException":
703
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
704
- case "ConflictException":
705
- case "com.amazonaws.qconnect#ConflictException":
706
- throw await de_ConflictExceptionRes(parsedOutput, context);
707
- case "ResourceNotFoundException":
708
- case "com.amazonaws.qconnect#ResourceNotFoundException":
709
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
710
- case "ServiceQuotaExceededException":
711
- case "com.amazonaws.qconnect#ServiceQuotaExceededException":
712
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
713
- case "ValidationException":
714
- case "com.amazonaws.qconnect#ValidationException":
715
- throw await de_ValidationExceptionRes(parsedOutput, context);
716
- default:
717
- const parsedBody = parsedOutput.body;
718
- return throwDefaultError({
719
- output,
720
- parsedBody,
721
- errorCode,
722
- });
723
- }
724
- };
725
635
  export const de_CreateKnowledgeBaseCommand = async (output, context) => {
726
636
  if (output.statusCode !== 200 && output.statusCode >= 300) {
727
- return de_CreateKnowledgeBaseCommandError(output, context);
637
+ return de_CommandError(output, context);
728
638
  }
729
639
  const contents = map({
730
640
  $metadata: deserializeMetadata(output),
@@ -736,37 +646,9 @@ export const de_CreateKnowledgeBaseCommand = async (output, context) => {
736
646
  Object.assign(contents, doc);
737
647
  return contents;
738
648
  };
739
- const de_CreateKnowledgeBaseCommandError = async (output, context) => {
740
- const parsedOutput = {
741
- ...output,
742
- body: await parseErrorBody(output.body, context),
743
- };
744
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
745
- switch (errorCode) {
746
- case "AccessDeniedException":
747
- case "com.amazonaws.qconnect#AccessDeniedException":
748
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
749
- case "ConflictException":
750
- case "com.amazonaws.qconnect#ConflictException":
751
- throw await de_ConflictExceptionRes(parsedOutput, context);
752
- case "ServiceQuotaExceededException":
753
- case "com.amazonaws.qconnect#ServiceQuotaExceededException":
754
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
755
- case "ValidationException":
756
- case "com.amazonaws.qconnect#ValidationException":
757
- throw await de_ValidationExceptionRes(parsedOutput, context);
758
- default:
759
- const parsedBody = parsedOutput.body;
760
- return throwDefaultError({
761
- output,
762
- parsedBody,
763
- errorCode,
764
- });
765
- }
766
- };
767
649
  export const de_CreateQuickResponseCommand = async (output, context) => {
768
650
  if (output.statusCode !== 200 && output.statusCode >= 300) {
769
- return de_CreateQuickResponseCommandError(output, context);
651
+ return de_CommandError(output, context);
770
652
  }
771
653
  const contents = map({
772
654
  $metadata: deserializeMetadata(output),
@@ -778,40 +660,9 @@ export const de_CreateQuickResponseCommand = async (output, context) => {
778
660
  Object.assign(contents, doc);
779
661
  return contents;
780
662
  };
781
- const de_CreateQuickResponseCommandError = async (output, context) => {
782
- const parsedOutput = {
783
- ...output,
784
- body: await parseErrorBody(output.body, context),
785
- };
786
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
787
- switch (errorCode) {
788
- case "AccessDeniedException":
789
- case "com.amazonaws.qconnect#AccessDeniedException":
790
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
791
- case "ConflictException":
792
- case "com.amazonaws.qconnect#ConflictException":
793
- throw await de_ConflictExceptionRes(parsedOutput, context);
794
- case "ResourceNotFoundException":
795
- case "com.amazonaws.qconnect#ResourceNotFoundException":
796
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
797
- case "ServiceQuotaExceededException":
798
- case "com.amazonaws.qconnect#ServiceQuotaExceededException":
799
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
800
- case "ValidationException":
801
- case "com.amazonaws.qconnect#ValidationException":
802
- throw await de_ValidationExceptionRes(parsedOutput, context);
803
- default:
804
- const parsedBody = parsedOutput.body;
805
- return throwDefaultError({
806
- output,
807
- parsedBody,
808
- errorCode,
809
- });
810
- }
811
- };
812
663
  export const de_CreateSessionCommand = async (output, context) => {
813
664
  if (output.statusCode !== 200 && output.statusCode >= 300) {
814
- return de_CreateSessionCommandError(output, context);
665
+ return de_CommandError(output, context);
815
666
  }
816
667
  const contents = map({
817
668
  $metadata: deserializeMetadata(output),
@@ -823,34 +674,9 @@ export const de_CreateSessionCommand = async (output, context) => {
823
674
  Object.assign(contents, doc);
824
675
  return contents;
825
676
  };
826
- const de_CreateSessionCommandError = async (output, context) => {
827
- const parsedOutput = {
828
- ...output,
829
- body: await parseErrorBody(output.body, context),
830
- };
831
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
832
- switch (errorCode) {
833
- case "ConflictException":
834
- case "com.amazonaws.qconnect#ConflictException":
835
- throw await de_ConflictExceptionRes(parsedOutput, context);
836
- case "ResourceNotFoundException":
837
- case "com.amazonaws.qconnect#ResourceNotFoundException":
838
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
839
- case "ValidationException":
840
- case "com.amazonaws.qconnect#ValidationException":
841
- throw await de_ValidationExceptionRes(parsedOutput, context);
842
- default:
843
- const parsedBody = parsedOutput.body;
844
- return throwDefaultError({
845
- output,
846
- parsedBody,
847
- errorCode,
848
- });
849
- }
850
- };
851
677
  export const de_DeleteAssistantCommand = async (output, context) => {
852
678
  if (output.statusCode !== 204 && output.statusCode >= 300) {
853
- return de_DeleteAssistantCommandError(output, context);
679
+ return de_CommandError(output, context);
854
680
  }
855
681
  const contents = map({
856
682
  $metadata: deserializeMetadata(output),
@@ -858,34 +684,9 @@ export const de_DeleteAssistantCommand = async (output, context) => {
858
684
  await collectBody(output.body, context);
859
685
  return contents;
860
686
  };
861
- const de_DeleteAssistantCommandError = async (output, context) => {
862
- const parsedOutput = {
863
- ...output,
864
- body: await parseErrorBody(output.body, context),
865
- };
866
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
867
- switch (errorCode) {
868
- case "AccessDeniedException":
869
- case "com.amazonaws.qconnect#AccessDeniedException":
870
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
871
- case "ResourceNotFoundException":
872
- case "com.amazonaws.qconnect#ResourceNotFoundException":
873
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
874
- case "ValidationException":
875
- case "com.amazonaws.qconnect#ValidationException":
876
- throw await de_ValidationExceptionRes(parsedOutput, context);
877
- default:
878
- const parsedBody = parsedOutput.body;
879
- return throwDefaultError({
880
- output,
881
- parsedBody,
882
- errorCode,
883
- });
884
- }
885
- };
886
687
  export const de_DeleteAssistantAssociationCommand = async (output, context) => {
887
688
  if (output.statusCode !== 204 && output.statusCode >= 300) {
888
- return de_DeleteAssistantAssociationCommandError(output, context);
689
+ return de_CommandError(output, context);
889
690
  }
890
691
  const contents = map({
891
692
  $metadata: deserializeMetadata(output),
@@ -893,34 +694,9 @@ export const de_DeleteAssistantAssociationCommand = async (output, context) => {
893
694
  await collectBody(output.body, context);
894
695
  return contents;
895
696
  };
896
- const de_DeleteAssistantAssociationCommandError = 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 "AccessDeniedException":
904
- case "com.amazonaws.qconnect#AccessDeniedException":
905
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
906
- case "ResourceNotFoundException":
907
- case "com.amazonaws.qconnect#ResourceNotFoundException":
908
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
909
- case "ValidationException":
910
- case "com.amazonaws.qconnect#ValidationException":
911
- throw await de_ValidationExceptionRes(parsedOutput, context);
912
- default:
913
- const parsedBody = parsedOutput.body;
914
- return throwDefaultError({
915
- output,
916
- parsedBody,
917
- errorCode,
918
- });
919
- }
920
- };
921
697
  export const de_DeleteContentCommand = async (output, context) => {
922
698
  if (output.statusCode !== 204 && output.statusCode >= 300) {
923
- return de_DeleteContentCommandError(output, context);
699
+ return de_CommandError(output, context);
924
700
  }
925
701
  const contents = map({
926
702
  $metadata: deserializeMetadata(output),
@@ -928,34 +704,9 @@ export const de_DeleteContentCommand = async (output, context) => {
928
704
  await collectBody(output.body, context);
929
705
  return contents;
930
706
  };
931
- const de_DeleteContentCommandError = async (output, context) => {
932
- const parsedOutput = {
933
- ...output,
934
- body: await parseErrorBody(output.body, context),
935
- };
936
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
937
- switch (errorCode) {
938
- case "AccessDeniedException":
939
- case "com.amazonaws.qconnect#AccessDeniedException":
940
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
941
- case "ResourceNotFoundException":
942
- case "com.amazonaws.qconnect#ResourceNotFoundException":
943
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
944
- case "ValidationException":
945
- case "com.amazonaws.qconnect#ValidationException":
946
- throw await de_ValidationExceptionRes(parsedOutput, context);
947
- default:
948
- const parsedBody = parsedOutput.body;
949
- return throwDefaultError({
950
- output,
951
- parsedBody,
952
- errorCode,
953
- });
954
- }
955
- };
956
707
  export const de_DeleteImportJobCommand = async (output, context) => {
957
708
  if (output.statusCode !== 204 && output.statusCode >= 300) {
958
- return de_DeleteImportJobCommandError(output, context);
709
+ return de_CommandError(output, context);
959
710
  }
960
711
  const contents = map({
961
712
  $metadata: deserializeMetadata(output),
@@ -963,37 +714,9 @@ export const de_DeleteImportJobCommand = async (output, context) => {
963
714
  await collectBody(output.body, context);
964
715
  return contents;
965
716
  };
966
- const de_DeleteImportJobCommandError = async (output, context) => {
967
- const parsedOutput = {
968
- ...output,
969
- body: await parseErrorBody(output.body, context),
970
- };
971
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
972
- switch (errorCode) {
973
- case "AccessDeniedException":
974
- case "com.amazonaws.qconnect#AccessDeniedException":
975
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
976
- case "ConflictException":
977
- case "com.amazonaws.qconnect#ConflictException":
978
- throw await de_ConflictExceptionRes(parsedOutput, context);
979
- case "ResourceNotFoundException":
980
- case "com.amazonaws.qconnect#ResourceNotFoundException":
981
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
982
- case "ValidationException":
983
- case "com.amazonaws.qconnect#ValidationException":
984
- throw await de_ValidationExceptionRes(parsedOutput, context);
985
- default:
986
- const parsedBody = parsedOutput.body;
987
- return throwDefaultError({
988
- output,
989
- parsedBody,
990
- errorCode,
991
- });
992
- }
993
- };
994
717
  export const de_DeleteKnowledgeBaseCommand = async (output, context) => {
995
718
  if (output.statusCode !== 204 && output.statusCode >= 300) {
996
- return de_DeleteKnowledgeBaseCommandError(output, context);
719
+ return de_CommandError(output, context);
997
720
  }
998
721
  const contents = map({
999
722
  $metadata: deserializeMetadata(output),
@@ -1001,72 +724,19 @@ export const de_DeleteKnowledgeBaseCommand = async (output, context) => {
1001
724
  await collectBody(output.body, context);
1002
725
  return contents;
1003
726
  };
1004
- const de_DeleteKnowledgeBaseCommandError = async (output, context) => {
1005
- const parsedOutput = {
1006
- ...output,
1007
- body: await parseErrorBody(output.body, context),
1008
- };
1009
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1010
- switch (errorCode) {
1011
- case "AccessDeniedException":
1012
- case "com.amazonaws.qconnect#AccessDeniedException":
1013
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1014
- case "ConflictException":
1015
- case "com.amazonaws.qconnect#ConflictException":
1016
- throw await de_ConflictExceptionRes(parsedOutput, context);
1017
- case "ResourceNotFoundException":
1018
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1019
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1020
- case "ValidationException":
1021
- case "com.amazonaws.qconnect#ValidationException":
1022
- throw await de_ValidationExceptionRes(parsedOutput, context);
1023
- default:
1024
- const parsedBody = parsedOutput.body;
1025
- return throwDefaultError({
1026
- output,
1027
- parsedBody,
1028
- errorCode,
1029
- });
1030
- }
1031
- };
1032
727
  export const de_DeleteQuickResponseCommand = async (output, context) => {
1033
728
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1034
- return de_DeleteQuickResponseCommandError(output, context);
729
+ return de_CommandError(output, context);
1035
730
  }
1036
731
  const contents = map({
1037
- $metadata: deserializeMetadata(output),
1038
- });
1039
- await collectBody(output.body, context);
1040
- return contents;
1041
- };
1042
- const de_DeleteQuickResponseCommandError = async (output, context) => {
1043
- const parsedOutput = {
1044
- ...output,
1045
- body: await parseErrorBody(output.body, context),
1046
- };
1047
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1048
- switch (errorCode) {
1049
- case "AccessDeniedException":
1050
- case "com.amazonaws.qconnect#AccessDeniedException":
1051
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1052
- case "ResourceNotFoundException":
1053
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1054
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1055
- case "ValidationException":
1056
- case "com.amazonaws.qconnect#ValidationException":
1057
- throw await de_ValidationExceptionRes(parsedOutput, context);
1058
- default:
1059
- const parsedBody = parsedOutput.body;
1060
- return throwDefaultError({
1061
- output,
1062
- parsedBody,
1063
- errorCode,
1064
- });
1065
- }
732
+ $metadata: deserializeMetadata(output),
733
+ });
734
+ await collectBody(output.body, context);
735
+ return contents;
1066
736
  };
1067
737
  export const de_GetAssistantCommand = async (output, context) => {
1068
738
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1069
- return de_GetAssistantCommandError(output, context);
739
+ return de_CommandError(output, context);
1070
740
  }
1071
741
  const contents = map({
1072
742
  $metadata: deserializeMetadata(output),
@@ -1078,34 +748,9 @@ export const de_GetAssistantCommand = async (output, context) => {
1078
748
  Object.assign(contents, doc);
1079
749
  return contents;
1080
750
  };
1081
- const de_GetAssistantCommandError = async (output, context) => {
1082
- const parsedOutput = {
1083
- ...output,
1084
- body: await parseErrorBody(output.body, context),
1085
- };
1086
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1087
- switch (errorCode) {
1088
- case "AccessDeniedException":
1089
- case "com.amazonaws.qconnect#AccessDeniedException":
1090
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1091
- case "ResourceNotFoundException":
1092
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1093
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1094
- case "ValidationException":
1095
- case "com.amazonaws.qconnect#ValidationException":
1096
- throw await de_ValidationExceptionRes(parsedOutput, context);
1097
- default:
1098
- const parsedBody = parsedOutput.body;
1099
- return throwDefaultError({
1100
- output,
1101
- parsedBody,
1102
- errorCode,
1103
- });
1104
- }
1105
- };
1106
751
  export const de_GetAssistantAssociationCommand = async (output, context) => {
1107
752
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1108
- return de_GetAssistantAssociationCommandError(output, context);
753
+ return de_CommandError(output, context);
1109
754
  }
1110
755
  const contents = map({
1111
756
  $metadata: deserializeMetadata(output),
@@ -1117,34 +762,9 @@ export const de_GetAssistantAssociationCommand = async (output, context) => {
1117
762
  Object.assign(contents, doc);
1118
763
  return contents;
1119
764
  };
1120
- const de_GetAssistantAssociationCommandError = async (output, context) => {
1121
- const parsedOutput = {
1122
- ...output,
1123
- body: await parseErrorBody(output.body, context),
1124
- };
1125
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1126
- switch (errorCode) {
1127
- case "AccessDeniedException":
1128
- case "com.amazonaws.qconnect#AccessDeniedException":
1129
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1130
- case "ResourceNotFoundException":
1131
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1132
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1133
- case "ValidationException":
1134
- case "com.amazonaws.qconnect#ValidationException":
1135
- throw await de_ValidationExceptionRes(parsedOutput, context);
1136
- default:
1137
- const parsedBody = parsedOutput.body;
1138
- return throwDefaultError({
1139
- output,
1140
- parsedBody,
1141
- errorCode,
1142
- });
1143
- }
1144
- };
1145
765
  export const de_GetContentCommand = async (output, context) => {
1146
766
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1147
- return de_GetContentCommandError(output, context);
767
+ return de_CommandError(output, context);
1148
768
  }
1149
769
  const contents = map({
1150
770
  $metadata: deserializeMetadata(output),
@@ -1156,34 +776,9 @@ export const de_GetContentCommand = async (output, context) => {
1156
776
  Object.assign(contents, doc);
1157
777
  return contents;
1158
778
  };
1159
- const de_GetContentCommandError = async (output, context) => {
1160
- const parsedOutput = {
1161
- ...output,
1162
- body: await parseErrorBody(output.body, context),
1163
- };
1164
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1165
- switch (errorCode) {
1166
- case "AccessDeniedException":
1167
- case "com.amazonaws.qconnect#AccessDeniedException":
1168
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1169
- case "ResourceNotFoundException":
1170
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1171
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1172
- case "ValidationException":
1173
- case "com.amazonaws.qconnect#ValidationException":
1174
- throw await de_ValidationExceptionRes(parsedOutput, context);
1175
- default:
1176
- const parsedBody = parsedOutput.body;
1177
- return throwDefaultError({
1178
- output,
1179
- parsedBody,
1180
- errorCode,
1181
- });
1182
- }
1183
- };
1184
779
  export const de_GetContentSummaryCommand = async (output, context) => {
1185
780
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1186
- return de_GetContentSummaryCommandError(output, context);
781
+ return de_CommandError(output, context);
1187
782
  }
1188
783
  const contents = map({
1189
784
  $metadata: deserializeMetadata(output),
@@ -1195,34 +790,9 @@ export const de_GetContentSummaryCommand = async (output, context) => {
1195
790
  Object.assign(contents, doc);
1196
791
  return contents;
1197
792
  };
1198
- const de_GetContentSummaryCommandError = async (output, context) => {
1199
- const parsedOutput = {
1200
- ...output,
1201
- body: await parseErrorBody(output.body, context),
1202
- };
1203
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1204
- switch (errorCode) {
1205
- case "AccessDeniedException":
1206
- case "com.amazonaws.qconnect#AccessDeniedException":
1207
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1208
- case "ResourceNotFoundException":
1209
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1210
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1211
- case "ValidationException":
1212
- case "com.amazonaws.qconnect#ValidationException":
1213
- throw await de_ValidationExceptionRes(parsedOutput, context);
1214
- default:
1215
- const parsedBody = parsedOutput.body;
1216
- return throwDefaultError({
1217
- output,
1218
- parsedBody,
1219
- errorCode,
1220
- });
1221
- }
1222
- };
1223
793
  export const de_GetImportJobCommand = async (output, context) => {
1224
794
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1225
- return de_GetImportJobCommandError(output, context);
795
+ return de_CommandError(output, context);
1226
796
  }
1227
797
  const contents = map({
1228
798
  $metadata: deserializeMetadata(output),
@@ -1234,34 +804,9 @@ export const de_GetImportJobCommand = async (output, context) => {
1234
804
  Object.assign(contents, doc);
1235
805
  return contents;
1236
806
  };
1237
- const de_GetImportJobCommandError = async (output, context) => {
1238
- const parsedOutput = {
1239
- ...output,
1240
- body: await parseErrorBody(output.body, context),
1241
- };
1242
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1243
- switch (errorCode) {
1244
- case "AccessDeniedException":
1245
- case "com.amazonaws.qconnect#AccessDeniedException":
1246
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1247
- case "ResourceNotFoundException":
1248
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1249
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1250
- case "ValidationException":
1251
- case "com.amazonaws.qconnect#ValidationException":
1252
- throw await de_ValidationExceptionRes(parsedOutput, context);
1253
- default:
1254
- const parsedBody = parsedOutput.body;
1255
- return throwDefaultError({
1256
- output,
1257
- parsedBody,
1258
- errorCode,
1259
- });
1260
- }
1261
- };
1262
807
  export const de_GetKnowledgeBaseCommand = async (output, context) => {
1263
808
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1264
- return de_GetKnowledgeBaseCommandError(output, context);
809
+ return de_CommandError(output, context);
1265
810
  }
1266
811
  const contents = map({
1267
812
  $metadata: deserializeMetadata(output),
@@ -1273,34 +818,9 @@ export const de_GetKnowledgeBaseCommand = async (output, context) => {
1273
818
  Object.assign(contents, doc);
1274
819
  return contents;
1275
820
  };
1276
- const de_GetKnowledgeBaseCommandError = async (output, context) => {
1277
- const parsedOutput = {
1278
- ...output,
1279
- body: await parseErrorBody(output.body, context),
1280
- };
1281
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1282
- switch (errorCode) {
1283
- case "AccessDeniedException":
1284
- case "com.amazonaws.qconnect#AccessDeniedException":
1285
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1286
- case "ResourceNotFoundException":
1287
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1288
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1289
- case "ValidationException":
1290
- case "com.amazonaws.qconnect#ValidationException":
1291
- throw await de_ValidationExceptionRes(parsedOutput, context);
1292
- default:
1293
- const parsedBody = parsedOutput.body;
1294
- return throwDefaultError({
1295
- output,
1296
- parsedBody,
1297
- errorCode,
1298
- });
1299
- }
1300
- };
1301
821
  export const de_GetQuickResponseCommand = async (output, context) => {
1302
822
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1303
- return de_GetQuickResponseCommandError(output, context);
823
+ return de_CommandError(output, context);
1304
824
  }
1305
825
  const contents = map({
1306
826
  $metadata: deserializeMetadata(output),
@@ -1312,34 +832,9 @@ export const de_GetQuickResponseCommand = async (output, context) => {
1312
832
  Object.assign(contents, doc);
1313
833
  return contents;
1314
834
  };
1315
- const de_GetQuickResponseCommandError = async (output, context) => {
1316
- const parsedOutput = {
1317
- ...output,
1318
- body: await parseErrorBody(output.body, context),
1319
- };
1320
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1321
- switch (errorCode) {
1322
- case "AccessDeniedException":
1323
- case "com.amazonaws.qconnect#AccessDeniedException":
1324
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1325
- case "ResourceNotFoundException":
1326
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1327
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1328
- case "ValidationException":
1329
- case "com.amazonaws.qconnect#ValidationException":
1330
- throw await de_ValidationExceptionRes(parsedOutput, context);
1331
- default:
1332
- const parsedBody = parsedOutput.body;
1333
- return throwDefaultError({
1334
- output,
1335
- parsedBody,
1336
- errorCode,
1337
- });
1338
- }
1339
- };
1340
835
  export const de_GetRecommendationsCommand = async (output, context) => {
1341
836
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1342
- return de_GetRecommendationsCommandError(output, context);
837
+ return de_CommandError(output, context);
1343
838
  }
1344
839
  const contents = map({
1345
840
  $metadata: deserializeMetadata(output),
@@ -1352,34 +847,9 @@ export const de_GetRecommendationsCommand = async (output, context) => {
1352
847
  Object.assign(contents, doc);
1353
848
  return contents;
1354
849
  };
1355
- const de_GetRecommendationsCommandError = async (output, context) => {
1356
- const parsedOutput = {
1357
- ...output,
1358
- body: await parseErrorBody(output.body, context),
1359
- };
1360
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1361
- switch (errorCode) {
1362
- case "AccessDeniedException":
1363
- case "com.amazonaws.qconnect#AccessDeniedException":
1364
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1365
- case "ResourceNotFoundException":
1366
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1367
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1368
- case "ValidationException":
1369
- case "com.amazonaws.qconnect#ValidationException":
1370
- throw await de_ValidationExceptionRes(parsedOutput, context);
1371
- default:
1372
- const parsedBody = parsedOutput.body;
1373
- return throwDefaultError({
1374
- output,
1375
- parsedBody,
1376
- errorCode,
1377
- });
1378
- }
1379
- };
1380
850
  export const de_GetSessionCommand = async (output, context) => {
1381
851
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1382
- return de_GetSessionCommandError(output, context);
852
+ return de_CommandError(output, context);
1383
853
  }
1384
854
  const contents = map({
1385
855
  $metadata: deserializeMetadata(output),
@@ -1391,74 +861,24 @@ export const de_GetSessionCommand = async (output, context) => {
1391
861
  Object.assign(contents, doc);
1392
862
  return contents;
1393
863
  };
1394
- const de_GetSessionCommandError = async (output, context) => {
1395
- const parsedOutput = {
1396
- ...output,
1397
- body: await parseErrorBody(output.body, context),
1398
- };
1399
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1400
- switch (errorCode) {
1401
- case "AccessDeniedException":
1402
- case "com.amazonaws.qconnect#AccessDeniedException":
1403
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1404
- case "ResourceNotFoundException":
1405
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1406
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1407
- case "ValidationException":
1408
- case "com.amazonaws.qconnect#ValidationException":
1409
- throw await de_ValidationExceptionRes(parsedOutput, context);
1410
- default:
1411
- const parsedBody = parsedOutput.body;
1412
- return throwDefaultError({
1413
- output,
1414
- parsedBody,
1415
- errorCode,
1416
- });
1417
- }
1418
- };
1419
- export const de_ListAssistantAssociationsCommand = async (output, context) => {
1420
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1421
- return de_ListAssistantAssociationsCommandError(output, context);
1422
- }
1423
- const contents = map({
1424
- $metadata: deserializeMetadata(output),
1425
- });
1426
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1427
- const doc = take(data, {
1428
- assistantAssociationSummaries: _json,
1429
- nextToken: __expectString,
1430
- });
1431
- Object.assign(contents, doc);
1432
- return contents;
1433
- };
1434
- const de_ListAssistantAssociationsCommandError = async (output, context) => {
1435
- const parsedOutput = {
1436
- ...output,
1437
- body: await parseErrorBody(output.body, context),
1438
- };
1439
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1440
- switch (errorCode) {
1441
- case "AccessDeniedException":
1442
- case "com.amazonaws.qconnect#AccessDeniedException":
1443
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1444
- case "ResourceNotFoundException":
1445
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1446
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1447
- case "ValidationException":
1448
- case "com.amazonaws.qconnect#ValidationException":
1449
- throw await de_ValidationExceptionRes(parsedOutput, context);
1450
- default:
1451
- const parsedBody = parsedOutput.body;
1452
- return throwDefaultError({
1453
- output,
1454
- parsedBody,
1455
- errorCode,
1456
- });
864
+ export const de_ListAssistantAssociationsCommand = async (output, context) => {
865
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
866
+ return de_CommandError(output, context);
1457
867
  }
868
+ const contents = map({
869
+ $metadata: deserializeMetadata(output),
870
+ });
871
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
872
+ const doc = take(data, {
873
+ assistantAssociationSummaries: _json,
874
+ nextToken: __expectString,
875
+ });
876
+ Object.assign(contents, doc);
877
+ return contents;
1458
878
  };
1459
879
  export const de_ListAssistantsCommand = async (output, context) => {
1460
880
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1461
- return de_ListAssistantsCommandError(output, context);
881
+ return de_CommandError(output, context);
1462
882
  }
1463
883
  const contents = map({
1464
884
  $metadata: deserializeMetadata(output),
@@ -1471,31 +891,9 @@ export const de_ListAssistantsCommand = async (output, context) => {
1471
891
  Object.assign(contents, doc);
1472
892
  return contents;
1473
893
  };
1474
- const de_ListAssistantsCommandError = async (output, context) => {
1475
- const parsedOutput = {
1476
- ...output,
1477
- body: await parseErrorBody(output.body, context),
1478
- };
1479
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1480
- switch (errorCode) {
1481
- case "AccessDeniedException":
1482
- case "com.amazonaws.qconnect#AccessDeniedException":
1483
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1484
- case "ValidationException":
1485
- case "com.amazonaws.qconnect#ValidationException":
1486
- throw await de_ValidationExceptionRes(parsedOutput, context);
1487
- default:
1488
- const parsedBody = parsedOutput.body;
1489
- return throwDefaultError({
1490
- output,
1491
- parsedBody,
1492
- errorCode,
1493
- });
1494
- }
1495
- };
1496
894
  export const de_ListContentsCommand = async (output, context) => {
1497
895
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1498
- return de_ListContentsCommandError(output, context);
896
+ return de_CommandError(output, context);
1499
897
  }
1500
898
  const contents = map({
1501
899
  $metadata: deserializeMetadata(output),
@@ -1508,34 +906,9 @@ export const de_ListContentsCommand = async (output, context) => {
1508
906
  Object.assign(contents, doc);
1509
907
  return contents;
1510
908
  };
1511
- const de_ListContentsCommandError = async (output, context) => {
1512
- const parsedOutput = {
1513
- ...output,
1514
- body: await parseErrorBody(output.body, context),
1515
- };
1516
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1517
- switch (errorCode) {
1518
- case "AccessDeniedException":
1519
- case "com.amazonaws.qconnect#AccessDeniedException":
1520
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1521
- case "ResourceNotFoundException":
1522
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1523
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1524
- case "ValidationException":
1525
- case "com.amazonaws.qconnect#ValidationException":
1526
- throw await de_ValidationExceptionRes(parsedOutput, context);
1527
- default:
1528
- const parsedBody = parsedOutput.body;
1529
- return throwDefaultError({
1530
- output,
1531
- parsedBody,
1532
- errorCode,
1533
- });
1534
- }
1535
- };
1536
909
  export const de_ListImportJobsCommand = async (output, context) => {
1537
910
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1538
- return de_ListImportJobsCommandError(output, context);
911
+ return de_CommandError(output, context);
1539
912
  }
1540
913
  const contents = map({
1541
914
  $metadata: deserializeMetadata(output),
@@ -1548,31 +921,9 @@ export const de_ListImportJobsCommand = async (output, context) => {
1548
921
  Object.assign(contents, doc);
1549
922
  return contents;
1550
923
  };
1551
- const de_ListImportJobsCommandError = async (output, context) => {
1552
- const parsedOutput = {
1553
- ...output,
1554
- body: await parseErrorBody(output.body, context),
1555
- };
1556
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1557
- switch (errorCode) {
1558
- case "AccessDeniedException":
1559
- case "com.amazonaws.qconnect#AccessDeniedException":
1560
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1561
- case "ValidationException":
1562
- case "com.amazonaws.qconnect#ValidationException":
1563
- throw await de_ValidationExceptionRes(parsedOutput, context);
1564
- default:
1565
- const parsedBody = parsedOutput.body;
1566
- return throwDefaultError({
1567
- output,
1568
- parsedBody,
1569
- errorCode,
1570
- });
1571
- }
1572
- };
1573
924
  export const de_ListKnowledgeBasesCommand = async (output, context) => {
1574
925
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1575
- return de_ListKnowledgeBasesCommandError(output, context);
926
+ return de_CommandError(output, context);
1576
927
  }
1577
928
  const contents = map({
1578
929
  $metadata: deserializeMetadata(output),
@@ -1585,31 +936,9 @@ export const de_ListKnowledgeBasesCommand = async (output, context) => {
1585
936
  Object.assign(contents, doc);
1586
937
  return contents;
1587
938
  };
1588
- const de_ListKnowledgeBasesCommandError = async (output, context) => {
1589
- const parsedOutput = {
1590
- ...output,
1591
- body: await parseErrorBody(output.body, context),
1592
- };
1593
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1594
- switch (errorCode) {
1595
- case "AccessDeniedException":
1596
- case "com.amazonaws.qconnect#AccessDeniedException":
1597
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1598
- case "ValidationException":
1599
- case "com.amazonaws.qconnect#ValidationException":
1600
- throw await de_ValidationExceptionRes(parsedOutput, context);
1601
- default:
1602
- const parsedBody = parsedOutput.body;
1603
- return throwDefaultError({
1604
- output,
1605
- parsedBody,
1606
- errorCode,
1607
- });
1608
- }
1609
- };
1610
939
  export const de_ListQuickResponsesCommand = async (output, context) => {
1611
940
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1612
- return de_ListQuickResponsesCommandError(output, context);
941
+ return de_CommandError(output, context);
1613
942
  }
1614
943
  const contents = map({
1615
944
  $metadata: deserializeMetadata(output),
@@ -1622,34 +951,9 @@ export const de_ListQuickResponsesCommand = async (output, context) => {
1622
951
  Object.assign(contents, doc);
1623
952
  return contents;
1624
953
  };
1625
- const de_ListQuickResponsesCommandError = 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 "AccessDeniedException":
1633
- case "com.amazonaws.qconnect#AccessDeniedException":
1634
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1635
- case "ResourceNotFoundException":
1636
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1637
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1638
- case "ValidationException":
1639
- case "com.amazonaws.qconnect#ValidationException":
1640
- throw await de_ValidationExceptionRes(parsedOutput, context);
1641
- default:
1642
- const parsedBody = parsedOutput.body;
1643
- return throwDefaultError({
1644
- output,
1645
- parsedBody,
1646
- errorCode,
1647
- });
1648
- }
1649
- };
1650
954
  export const de_ListTagsForResourceCommand = async (output, context) => {
1651
955
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1652
- return de_ListTagsForResourceCommandError(output, context);
956
+ return de_CommandError(output, context);
1653
957
  }
1654
958
  const contents = map({
1655
959
  $metadata: deserializeMetadata(output),
@@ -1661,28 +965,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
1661
965
  Object.assign(contents, doc);
1662
966
  return contents;
1663
967
  };
1664
- const de_ListTagsForResourceCommandError = async (output, context) => {
1665
- const parsedOutput = {
1666
- ...output,
1667
- body: await parseErrorBody(output.body, context),
1668
- };
1669
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1670
- switch (errorCode) {
1671
- case "ResourceNotFoundException":
1672
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1673
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1674
- default:
1675
- const parsedBody = parsedOutput.body;
1676
- return throwDefaultError({
1677
- output,
1678
- parsedBody,
1679
- errorCode,
1680
- });
1681
- }
1682
- };
1683
968
  export const de_NotifyRecommendationsReceivedCommand = async (output, context) => {
1684
969
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1685
- return de_NotifyRecommendationsReceivedCommandError(output, context);
970
+ return de_CommandError(output, context);
1686
971
  }
1687
972
  const contents = map({
1688
973
  $metadata: deserializeMetadata(output),
@@ -1695,34 +980,9 @@ export const de_NotifyRecommendationsReceivedCommand = async (output, context) =
1695
980
  Object.assign(contents, doc);
1696
981
  return contents;
1697
982
  };
1698
- const de_NotifyRecommendationsReceivedCommandError = async (output, context) => {
1699
- const parsedOutput = {
1700
- ...output,
1701
- body: await parseErrorBody(output.body, context),
1702
- };
1703
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1704
- switch (errorCode) {
1705
- case "AccessDeniedException":
1706
- case "com.amazonaws.qconnect#AccessDeniedException":
1707
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1708
- case "ResourceNotFoundException":
1709
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1710
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1711
- case "ValidationException":
1712
- case "com.amazonaws.qconnect#ValidationException":
1713
- throw await de_ValidationExceptionRes(parsedOutput, context);
1714
- default:
1715
- const parsedBody = parsedOutput.body;
1716
- return throwDefaultError({
1717
- output,
1718
- parsedBody,
1719
- errorCode,
1720
- });
1721
- }
1722
- };
1723
983
  export const de_PutFeedbackCommand = async (output, context) => {
1724
984
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1725
- return de_PutFeedbackCommandError(output, context);
985
+ return de_CommandError(output, context);
1726
986
  }
1727
987
  const contents = map({
1728
988
  $metadata: deserializeMetadata(output),
@@ -1738,112 +998,34 @@ export const de_PutFeedbackCommand = async (output, context) => {
1738
998
  Object.assign(contents, doc);
1739
999
  return contents;
1740
1000
  };
1741
- const de_PutFeedbackCommandError = async (output, context) => {
1742
- const parsedOutput = {
1743
- ...output,
1744
- body: await parseErrorBody(output.body, context),
1745
- };
1746
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1747
- switch (errorCode) {
1748
- case "AccessDeniedException":
1749
- case "com.amazonaws.qconnect#AccessDeniedException":
1750
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1751
- case "ResourceNotFoundException":
1752
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1753
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1754
- case "ValidationException":
1755
- case "com.amazonaws.qconnect#ValidationException":
1756
- throw await de_ValidationExceptionRes(parsedOutput, context);
1757
- default:
1758
- const parsedBody = parsedOutput.body;
1759
- return throwDefaultError({
1760
- output,
1761
- parsedBody,
1762
- errorCode,
1763
- });
1764
- }
1765
- };
1766
1001
  export const de_QueryAssistantCommand = async (output, context) => {
1767
1002
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1768
- return de_QueryAssistantCommandError(output, context);
1769
- }
1770
- const contents = map({
1771
- $metadata: deserializeMetadata(output),
1772
- });
1773
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1774
- const doc = take(data, {
1775
- nextToken: __expectString,
1776
- results: (_) => de_QueryResultsList(_, context),
1777
- });
1778
- Object.assign(contents, doc);
1779
- return contents;
1780
- };
1781
- const de_QueryAssistantCommandError = async (output, context) => {
1782
- const parsedOutput = {
1783
- ...output,
1784
- body: await parseErrorBody(output.body, context),
1785
- };
1786
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1787
- switch (errorCode) {
1788
- case "AccessDeniedException":
1789
- case "com.amazonaws.qconnect#AccessDeniedException":
1790
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1791
- case "RequestTimeoutException":
1792
- case "com.amazonaws.qconnect#RequestTimeoutException":
1793
- throw await de_RequestTimeoutExceptionRes(parsedOutput, context);
1794
- case "ResourceNotFoundException":
1795
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1796
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1797
- case "ValidationException":
1798
- case "com.amazonaws.qconnect#ValidationException":
1799
- throw await de_ValidationExceptionRes(parsedOutput, context);
1800
- default:
1801
- const parsedBody = parsedOutput.body;
1802
- return throwDefaultError({
1803
- output,
1804
- parsedBody,
1805
- errorCode,
1806
- });
1807
- }
1808
- };
1809
- export const de_RemoveKnowledgeBaseTemplateUriCommand = async (output, context) => {
1810
- if (output.statusCode !== 204 && output.statusCode >= 300) {
1811
- return de_RemoveKnowledgeBaseTemplateUriCommandError(output, context);
1003
+ return de_CommandError(output, context);
1812
1004
  }
1813
1005
  const contents = map({
1814
1006
  $metadata: deserializeMetadata(output),
1815
- });
1816
- await collectBody(output.body, context);
1817
- return contents;
1818
- };
1819
- const de_RemoveKnowledgeBaseTemplateUriCommandError = async (output, context) => {
1820
- const parsedOutput = {
1821
- ...output,
1822
- body: await parseErrorBody(output.body, context),
1823
- };
1824
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1825
- switch (errorCode) {
1826
- case "AccessDeniedException":
1827
- case "com.amazonaws.qconnect#AccessDeniedException":
1828
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1829
- case "ResourceNotFoundException":
1830
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1831
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1832
- case "ValidationException":
1833
- case "com.amazonaws.qconnect#ValidationException":
1834
- throw await de_ValidationExceptionRes(parsedOutput, context);
1835
- default:
1836
- const parsedBody = parsedOutput.body;
1837
- return throwDefaultError({
1838
- output,
1839
- parsedBody,
1840
- errorCode,
1841
- });
1007
+ });
1008
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1009
+ const doc = take(data, {
1010
+ nextToken: __expectString,
1011
+ results: (_) => de_QueryResultsList(_, context),
1012
+ });
1013
+ Object.assign(contents, doc);
1014
+ return contents;
1015
+ };
1016
+ export const de_RemoveKnowledgeBaseTemplateUriCommand = async (output, context) => {
1017
+ if (output.statusCode !== 204 && output.statusCode >= 300) {
1018
+ return de_CommandError(output, context);
1842
1019
  }
1020
+ const contents = map({
1021
+ $metadata: deserializeMetadata(output),
1022
+ });
1023
+ await collectBody(output.body, context);
1024
+ return contents;
1843
1025
  };
1844
1026
  export const de_SearchContentCommand = async (output, context) => {
1845
1027
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1846
- return de_SearchContentCommandError(output, context);
1028
+ return de_CommandError(output, context);
1847
1029
  }
1848
1030
  const contents = map({
1849
1031
  $metadata: deserializeMetadata(output),
@@ -1856,34 +1038,9 @@ export const de_SearchContentCommand = async (output, context) => {
1856
1038
  Object.assign(contents, doc);
1857
1039
  return contents;
1858
1040
  };
1859
- const de_SearchContentCommandError = async (output, context) => {
1860
- const parsedOutput = {
1861
- ...output,
1862
- body: await parseErrorBody(output.body, context),
1863
- };
1864
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1865
- switch (errorCode) {
1866
- case "AccessDeniedException":
1867
- case "com.amazonaws.qconnect#AccessDeniedException":
1868
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1869
- case "ResourceNotFoundException":
1870
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1871
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1872
- case "ValidationException":
1873
- case "com.amazonaws.qconnect#ValidationException":
1874
- throw await de_ValidationExceptionRes(parsedOutput, context);
1875
- default:
1876
- const parsedBody = parsedOutput.body;
1877
- return throwDefaultError({
1878
- output,
1879
- parsedBody,
1880
- errorCode,
1881
- });
1882
- }
1883
- };
1884
1041
  export const de_SearchQuickResponsesCommand = async (output, context) => {
1885
1042
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1886
- return de_SearchQuickResponsesCommandError(output, context);
1043
+ return de_CommandError(output, context);
1887
1044
  }
1888
1045
  const contents = map({
1889
1046
  $metadata: deserializeMetadata(output),
@@ -1896,37 +1053,9 @@ export const de_SearchQuickResponsesCommand = async (output, context) => {
1896
1053
  Object.assign(contents, doc);
1897
1054
  return contents;
1898
1055
  };
1899
- const de_SearchQuickResponsesCommandError = async (output, context) => {
1900
- const parsedOutput = {
1901
- ...output,
1902
- body: await parseErrorBody(output.body, context),
1903
- };
1904
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1905
- switch (errorCode) {
1906
- case "AccessDeniedException":
1907
- case "com.amazonaws.qconnect#AccessDeniedException":
1908
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1909
- case "RequestTimeoutException":
1910
- case "com.amazonaws.qconnect#RequestTimeoutException":
1911
- throw await de_RequestTimeoutExceptionRes(parsedOutput, context);
1912
- case "ResourceNotFoundException":
1913
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1914
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1915
- case "ValidationException":
1916
- case "com.amazonaws.qconnect#ValidationException":
1917
- throw await de_ValidationExceptionRes(parsedOutput, context);
1918
- default:
1919
- const parsedBody = parsedOutput.body;
1920
- return throwDefaultError({
1921
- output,
1922
- parsedBody,
1923
- errorCode,
1924
- });
1925
- }
1926
- };
1927
1056
  export const de_SearchSessionsCommand = async (output, context) => {
1928
1057
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1929
- return de_SearchSessionsCommandError(output, context);
1058
+ return de_CommandError(output, context);
1930
1059
  }
1931
1060
  const contents = map({
1932
1061
  $metadata: deserializeMetadata(output),
@@ -1939,34 +1068,9 @@ export const de_SearchSessionsCommand = async (output, context) => {
1939
1068
  Object.assign(contents, doc);
1940
1069
  return contents;
1941
1070
  };
1942
- const de_SearchSessionsCommandError = async (output, context) => {
1943
- const parsedOutput = {
1944
- ...output,
1945
- body: await parseErrorBody(output.body, context),
1946
- };
1947
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1948
- switch (errorCode) {
1949
- case "AccessDeniedException":
1950
- case "com.amazonaws.qconnect#AccessDeniedException":
1951
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1952
- case "ResourceNotFoundException":
1953
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1954
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1955
- case "ValidationException":
1956
- case "com.amazonaws.qconnect#ValidationException":
1957
- throw await de_ValidationExceptionRes(parsedOutput, context);
1958
- default:
1959
- const parsedBody = parsedOutput.body;
1960
- return throwDefaultError({
1961
- output,
1962
- parsedBody,
1963
- errorCode,
1964
- });
1965
- }
1966
- };
1967
1071
  export const de_StartContentUploadCommand = async (output, context) => {
1968
1072
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1969
- return de_StartContentUploadCommandError(output, context);
1073
+ return de_CommandError(output, context);
1970
1074
  }
1971
1075
  const contents = map({
1972
1076
  $metadata: deserializeMetadata(output),
@@ -1981,34 +1085,9 @@ export const de_StartContentUploadCommand = async (output, context) => {
1981
1085
  Object.assign(contents, doc);
1982
1086
  return contents;
1983
1087
  };
1984
- const de_StartContentUploadCommandError = async (output, context) => {
1985
- const parsedOutput = {
1986
- ...output,
1987
- body: await parseErrorBody(output.body, context),
1988
- };
1989
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1990
- switch (errorCode) {
1991
- case "AccessDeniedException":
1992
- case "com.amazonaws.qconnect#AccessDeniedException":
1993
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1994
- case "ResourceNotFoundException":
1995
- case "com.amazonaws.qconnect#ResourceNotFoundException":
1996
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1997
- case "ValidationException":
1998
- case "com.amazonaws.qconnect#ValidationException":
1999
- throw await de_ValidationExceptionRes(parsedOutput, context);
2000
- default:
2001
- const parsedBody = parsedOutput.body;
2002
- return throwDefaultError({
2003
- output,
2004
- parsedBody,
2005
- errorCode,
2006
- });
2007
- }
2008
- };
2009
1088
  export const de_StartImportJobCommand = async (output, context) => {
2010
1089
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2011
- return de_StartImportJobCommandError(output, context);
1090
+ return de_CommandError(output, context);
2012
1091
  }
2013
1092
  const contents = map({
2014
1093
  $metadata: deserializeMetadata(output),
@@ -2020,40 +1099,9 @@ export const de_StartImportJobCommand = async (output, context) => {
2020
1099
  Object.assign(contents, doc);
2021
1100
  return contents;
2022
1101
  };
2023
- const de_StartImportJobCommandError = async (output, context) => {
2024
- const parsedOutput = {
2025
- ...output,
2026
- body: await parseErrorBody(output.body, context),
2027
- };
2028
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2029
- switch (errorCode) {
2030
- case "AccessDeniedException":
2031
- case "com.amazonaws.qconnect#AccessDeniedException":
2032
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2033
- case "ConflictException":
2034
- case "com.amazonaws.qconnect#ConflictException":
2035
- throw await de_ConflictExceptionRes(parsedOutput, context);
2036
- case "ResourceNotFoundException":
2037
- case "com.amazonaws.qconnect#ResourceNotFoundException":
2038
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2039
- case "ServiceQuotaExceededException":
2040
- case "com.amazonaws.qconnect#ServiceQuotaExceededException":
2041
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2042
- case "ValidationException":
2043
- case "com.amazonaws.qconnect#ValidationException":
2044
- throw await de_ValidationExceptionRes(parsedOutput, context);
2045
- default:
2046
- const parsedBody = parsedOutput.body;
2047
- return throwDefaultError({
2048
- output,
2049
- parsedBody,
2050
- errorCode,
2051
- });
2052
- }
2053
- };
2054
1102
  export const de_TagResourceCommand = async (output, context) => {
2055
1103
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2056
- return de_TagResourceCommandError(output, context);
1104
+ return de_CommandError(output, context);
2057
1105
  }
2058
1106
  const contents = map({
2059
1107
  $metadata: deserializeMetadata(output),
@@ -2061,31 +1109,9 @@ export const de_TagResourceCommand = async (output, context) => {
2061
1109
  await collectBody(output.body, context);
2062
1110
  return contents;
2063
1111
  };
2064
- const de_TagResourceCommandError = async (output, context) => {
2065
- const parsedOutput = {
2066
- ...output,
2067
- body: await parseErrorBody(output.body, context),
2068
- };
2069
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2070
- switch (errorCode) {
2071
- case "ResourceNotFoundException":
2072
- case "com.amazonaws.qconnect#ResourceNotFoundException":
2073
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2074
- case "TooManyTagsException":
2075
- case "com.amazonaws.qconnect#TooManyTagsException":
2076
- throw await de_TooManyTagsExceptionRes(parsedOutput, context);
2077
- default:
2078
- const parsedBody = parsedOutput.body;
2079
- return throwDefaultError({
2080
- output,
2081
- parsedBody,
2082
- errorCode,
2083
- });
2084
- }
2085
- };
2086
1112
  export const de_UntagResourceCommand = async (output, context) => {
2087
1113
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2088
- return de_UntagResourceCommandError(output, context);
1114
+ return de_CommandError(output, context);
2089
1115
  }
2090
1116
  const contents = map({
2091
1117
  $metadata: deserializeMetadata(output),
@@ -2093,28 +1119,9 @@ export const de_UntagResourceCommand = async (output, context) => {
2093
1119
  await collectBody(output.body, context);
2094
1120
  return contents;
2095
1121
  };
2096
- const de_UntagResourceCommandError = async (output, context) => {
2097
- const parsedOutput = {
2098
- ...output,
2099
- body: await parseErrorBody(output.body, context),
2100
- };
2101
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2102
- switch (errorCode) {
2103
- case "ResourceNotFoundException":
2104
- case "com.amazonaws.qconnect#ResourceNotFoundException":
2105
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2106
- default:
2107
- const parsedBody = parsedOutput.body;
2108
- return throwDefaultError({
2109
- output,
2110
- parsedBody,
2111
- errorCode,
2112
- });
2113
- }
2114
- };
2115
1122
  export const de_UpdateContentCommand = async (output, context) => {
2116
1123
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2117
- return de_UpdateContentCommandError(output, context);
1124
+ return de_CommandError(output, context);
2118
1125
  }
2119
1126
  const contents = map({
2120
1127
  $metadata: deserializeMetadata(output),
@@ -2126,37 +1133,9 @@ export const de_UpdateContentCommand = async (output, context) => {
2126
1133
  Object.assign(contents, doc);
2127
1134
  return contents;
2128
1135
  };
2129
- const de_UpdateContentCommandError = async (output, context) => {
2130
- const parsedOutput = {
2131
- ...output,
2132
- body: await parseErrorBody(output.body, context),
2133
- };
2134
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2135
- switch (errorCode) {
2136
- case "AccessDeniedException":
2137
- case "com.amazonaws.qconnect#AccessDeniedException":
2138
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2139
- case "PreconditionFailedException":
2140
- case "com.amazonaws.qconnect#PreconditionFailedException":
2141
- throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
2142
- case "ResourceNotFoundException":
2143
- case "com.amazonaws.qconnect#ResourceNotFoundException":
2144
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2145
- case "ValidationException":
2146
- case "com.amazonaws.qconnect#ValidationException":
2147
- throw await de_ValidationExceptionRes(parsedOutput, context);
2148
- default:
2149
- const parsedBody = parsedOutput.body;
2150
- return throwDefaultError({
2151
- output,
2152
- parsedBody,
2153
- errorCode,
2154
- });
2155
- }
2156
- };
2157
1136
  export const de_UpdateKnowledgeBaseTemplateUriCommand = async (output, context) => {
2158
1137
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2159
- return de_UpdateKnowledgeBaseTemplateUriCommandError(output, context);
1138
+ return de_CommandError(output, context);
2160
1139
  }
2161
1140
  const contents = map({
2162
1141
  $metadata: deserializeMetadata(output),
@@ -2168,34 +1147,9 @@ export const de_UpdateKnowledgeBaseTemplateUriCommand = async (output, context)
2168
1147
  Object.assign(contents, doc);
2169
1148
  return contents;
2170
1149
  };
2171
- const de_UpdateKnowledgeBaseTemplateUriCommandError = async (output, context) => {
2172
- const parsedOutput = {
2173
- ...output,
2174
- body: await parseErrorBody(output.body, context),
2175
- };
2176
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2177
- switch (errorCode) {
2178
- case "AccessDeniedException":
2179
- case "com.amazonaws.qconnect#AccessDeniedException":
2180
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2181
- case "ResourceNotFoundException":
2182
- case "com.amazonaws.qconnect#ResourceNotFoundException":
2183
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2184
- case "ValidationException":
2185
- case "com.amazonaws.qconnect#ValidationException":
2186
- throw await de_ValidationExceptionRes(parsedOutput, context);
2187
- default:
2188
- const parsedBody = parsedOutput.body;
2189
- return throwDefaultError({
2190
- output,
2191
- parsedBody,
2192
- errorCode,
2193
- });
2194
- }
2195
- };
2196
1150
  export const de_UpdateQuickResponseCommand = async (output, context) => {
2197
1151
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2198
- return de_UpdateQuickResponseCommandError(output, context);
1152
+ return de_CommandError(output, context);
2199
1153
  }
2200
1154
  const contents = map({
2201
1155
  $metadata: deserializeMetadata(output),
@@ -2207,7 +1161,7 @@ export const de_UpdateQuickResponseCommand = async (output, context) => {
2207
1161
  Object.assign(contents, doc);
2208
1162
  return contents;
2209
1163
  };
2210
- const de_UpdateQuickResponseCommandError = async (output, context) => {
1164
+ const de_CommandError = async (output, context) => {
2211
1165
  const parsedOutput = {
2212
1166
  ...output,
2213
1167
  body: await parseErrorBody(output.body, context),
@@ -2220,15 +1174,24 @@ const de_UpdateQuickResponseCommandError = async (output, context) => {
2220
1174
  case "ConflictException":
2221
1175
  case "com.amazonaws.qconnect#ConflictException":
2222
1176
  throw await de_ConflictExceptionRes(parsedOutput, context);
2223
- case "PreconditionFailedException":
2224
- case "com.amazonaws.qconnect#PreconditionFailedException":
2225
- throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
2226
- case "ResourceNotFoundException":
2227
- case "com.amazonaws.qconnect#ResourceNotFoundException":
2228
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1177
+ case "ServiceQuotaExceededException":
1178
+ case "com.amazonaws.qconnect#ServiceQuotaExceededException":
1179
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2229
1180
  case "ValidationException":
2230
1181
  case "com.amazonaws.qconnect#ValidationException":
2231
1182
  throw await de_ValidationExceptionRes(parsedOutput, context);
1183
+ case "ResourceNotFoundException":
1184
+ case "com.amazonaws.qconnect#ResourceNotFoundException":
1185
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1186
+ case "RequestTimeoutException":
1187
+ case "com.amazonaws.qconnect#RequestTimeoutException":
1188
+ throw await de_RequestTimeoutExceptionRes(parsedOutput, context);
1189
+ case "TooManyTagsException":
1190
+ case "com.amazonaws.qconnect#TooManyTagsException":
1191
+ throw await de_TooManyTagsExceptionRes(parsedOutput, context);
1192
+ case "PreconditionFailedException":
1193
+ case "com.amazonaws.qconnect#PreconditionFailedException":
1194
+ throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
2232
1195
  default:
2233
1196
  const parsedBody = parsedOutput.body;
2234
1197
  return throwDefaultError({