@aws-sdk/client-workdocs 3.504.0 → 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 +126 -1591
  2. package/dist-es/protocols/Aws_restJson1.js +231 -1696
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -676,7 +676,7 @@ export const se_UpdateUserCommand = async (input, context) => {
676
676
  };
677
677
  export const de_AbortDocumentVersionUploadCommand = async (output, context) => {
678
678
  if (output.statusCode !== 204 && output.statusCode >= 300) {
679
- return de_AbortDocumentVersionUploadCommandError(output, context);
679
+ return de_CommandError(output, context);
680
680
  }
681
681
  const contents = map({
682
682
  $metadata: deserializeMetadata(output),
@@ -684,46 +684,9 @@ export const de_AbortDocumentVersionUploadCommand = async (output, context) => {
684
684
  await collectBody(output.body, context);
685
685
  return contents;
686
686
  };
687
- const de_AbortDocumentVersionUploadCommandError = async (output, context) => {
688
- const parsedOutput = {
689
- ...output,
690
- body: await parseErrorBody(output.body, context),
691
- };
692
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
693
- switch (errorCode) {
694
- case "ConcurrentModificationException":
695
- case "com.amazonaws.workdocs#ConcurrentModificationException":
696
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
697
- case "EntityNotExistsException":
698
- case "com.amazonaws.workdocs#EntityNotExistsException":
699
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
700
- case "FailedDependencyException":
701
- case "com.amazonaws.workdocs#FailedDependencyException":
702
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
703
- case "ProhibitedStateException":
704
- case "com.amazonaws.workdocs#ProhibitedStateException":
705
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
706
- case "ServiceUnavailableException":
707
- case "com.amazonaws.workdocs#ServiceUnavailableException":
708
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
709
- case "UnauthorizedOperationException":
710
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
711
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
712
- case "UnauthorizedResourceAccessException":
713
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
714
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
715
- default:
716
- const parsedBody = parsedOutput.body;
717
- return throwDefaultError({
718
- output,
719
- parsedBody,
720
- errorCode,
721
- });
722
- }
723
- };
724
687
  export const de_ActivateUserCommand = async (output, context) => {
725
688
  if (output.statusCode !== 200 && output.statusCode >= 300) {
726
- return de_ActivateUserCommandError(output, context);
689
+ return de_CommandError(output, context);
727
690
  }
728
691
  const contents = map({
729
692
  $metadata: deserializeMetadata(output),
@@ -735,40 +698,9 @@ export const de_ActivateUserCommand = async (output, context) => {
735
698
  Object.assign(contents, doc);
736
699
  return contents;
737
700
  };
738
- const de_ActivateUserCommandError = async (output, context) => {
739
- const parsedOutput = {
740
- ...output,
741
- body: await parseErrorBody(output.body, context),
742
- };
743
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
744
- switch (errorCode) {
745
- case "EntityNotExistsException":
746
- case "com.amazonaws.workdocs#EntityNotExistsException":
747
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
748
- case "FailedDependencyException":
749
- case "com.amazonaws.workdocs#FailedDependencyException":
750
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
751
- case "ServiceUnavailableException":
752
- case "com.amazonaws.workdocs#ServiceUnavailableException":
753
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
754
- case "UnauthorizedOperationException":
755
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
756
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
757
- case "UnauthorizedResourceAccessException":
758
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
759
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
760
- default:
761
- const parsedBody = parsedOutput.body;
762
- return throwDefaultError({
763
- output,
764
- parsedBody,
765
- errorCode,
766
- });
767
- }
768
- };
769
701
  export const de_AddResourcePermissionsCommand = async (output, context) => {
770
702
  if (output.statusCode !== 201 && output.statusCode >= 300) {
771
- return de_AddResourcePermissionsCommandError(output, context);
703
+ return de_CommandError(output, context);
772
704
  }
773
705
  const contents = map({
774
706
  $metadata: deserializeMetadata(output),
@@ -780,40 +712,9 @@ export const de_AddResourcePermissionsCommand = async (output, context) => {
780
712
  Object.assign(contents, doc);
781
713
  return contents;
782
714
  };
783
- const de_AddResourcePermissionsCommandError = async (output, context) => {
784
- const parsedOutput = {
785
- ...output,
786
- body: await parseErrorBody(output.body, context),
787
- };
788
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
789
- switch (errorCode) {
790
- case "FailedDependencyException":
791
- case "com.amazonaws.workdocs#FailedDependencyException":
792
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
793
- case "ProhibitedStateException":
794
- case "com.amazonaws.workdocs#ProhibitedStateException":
795
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
796
- case "ServiceUnavailableException":
797
- case "com.amazonaws.workdocs#ServiceUnavailableException":
798
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
799
- case "UnauthorizedOperationException":
800
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
801
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
802
- case "UnauthorizedResourceAccessException":
803
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
804
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
805
- default:
806
- const parsedBody = parsedOutput.body;
807
- return throwDefaultError({
808
- output,
809
- parsedBody,
810
- errorCode,
811
- });
812
- }
813
- };
814
715
  export const de_CreateCommentCommand = async (output, context) => {
815
716
  if (output.statusCode !== 201 && output.statusCode >= 300) {
816
- return de_CreateCommentCommandError(output, context);
717
+ return de_CommandError(output, context);
817
718
  }
818
719
  const contents = map({
819
720
  $metadata: deserializeMetadata(output),
@@ -825,49 +726,9 @@ export const de_CreateCommentCommand = async (output, context) => {
825
726
  Object.assign(contents, doc);
826
727
  return contents;
827
728
  };
828
- const de_CreateCommentCommandError = async (output, context) => {
829
- const parsedOutput = {
830
- ...output,
831
- body: await parseErrorBody(output.body, context),
832
- };
833
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
834
- switch (errorCode) {
835
- case "DocumentLockedForCommentsException":
836
- case "com.amazonaws.workdocs#DocumentLockedForCommentsException":
837
- throw await de_DocumentLockedForCommentsExceptionRes(parsedOutput, context);
838
- case "EntityNotExistsException":
839
- case "com.amazonaws.workdocs#EntityNotExistsException":
840
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
841
- case "FailedDependencyException":
842
- case "com.amazonaws.workdocs#FailedDependencyException":
843
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
844
- case "InvalidCommentOperationException":
845
- case "com.amazonaws.workdocs#InvalidCommentOperationException":
846
- throw await de_InvalidCommentOperationExceptionRes(parsedOutput, context);
847
- case "ProhibitedStateException":
848
- case "com.amazonaws.workdocs#ProhibitedStateException":
849
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
850
- case "ServiceUnavailableException":
851
- case "com.amazonaws.workdocs#ServiceUnavailableException":
852
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
853
- case "UnauthorizedOperationException":
854
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
855
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
856
- case "UnauthorizedResourceAccessException":
857
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
858
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
859
- default:
860
- const parsedBody = parsedOutput.body;
861
- return throwDefaultError({
862
- output,
863
- parsedBody,
864
- errorCode,
865
- });
866
- }
867
- };
868
729
  export const de_CreateCustomMetadataCommand = async (output, context) => {
869
730
  if (output.statusCode !== 200 && output.statusCode >= 300) {
870
- return de_CreateCustomMetadataCommandError(output, context);
731
+ return de_CommandError(output, context);
871
732
  }
872
733
  const contents = map({
873
734
  $metadata: deserializeMetadata(output),
@@ -875,46 +736,9 @@ export const de_CreateCustomMetadataCommand = async (output, context) => {
875
736
  await collectBody(output.body, context);
876
737
  return contents;
877
738
  };
878
- const de_CreateCustomMetadataCommandError = async (output, context) => {
879
- const parsedOutput = {
880
- ...output,
881
- body: await parseErrorBody(output.body, context),
882
- };
883
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
884
- switch (errorCode) {
885
- case "CustomMetadataLimitExceededException":
886
- case "com.amazonaws.workdocs#CustomMetadataLimitExceededException":
887
- throw await de_CustomMetadataLimitExceededExceptionRes(parsedOutput, context);
888
- case "EntityNotExistsException":
889
- case "com.amazonaws.workdocs#EntityNotExistsException":
890
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
891
- case "FailedDependencyException":
892
- case "com.amazonaws.workdocs#FailedDependencyException":
893
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
894
- case "ProhibitedStateException":
895
- case "com.amazonaws.workdocs#ProhibitedStateException":
896
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
897
- case "ServiceUnavailableException":
898
- case "com.amazonaws.workdocs#ServiceUnavailableException":
899
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
900
- case "UnauthorizedOperationException":
901
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
902
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
903
- case "UnauthorizedResourceAccessException":
904
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
905
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
906
- default:
907
- const parsedBody = parsedOutput.body;
908
- return throwDefaultError({
909
- output,
910
- parsedBody,
911
- errorCode,
912
- });
913
- }
914
- };
915
739
  export const de_CreateFolderCommand = async (output, context) => {
916
740
  if (output.statusCode !== 201 && output.statusCode >= 300) {
917
- return de_CreateFolderCommandError(output, context);
741
+ return de_CommandError(output, context);
918
742
  }
919
743
  const contents = map({
920
744
  $metadata: deserializeMetadata(output),
@@ -926,55 +750,9 @@ export const de_CreateFolderCommand = async (output, context) => {
926
750
  Object.assign(contents, doc);
927
751
  return contents;
928
752
  };
929
- const de_CreateFolderCommandError = async (output, context) => {
930
- const parsedOutput = {
931
- ...output,
932
- body: await parseErrorBody(output.body, context),
933
- };
934
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
935
- switch (errorCode) {
936
- case "ConcurrentModificationException":
937
- case "com.amazonaws.workdocs#ConcurrentModificationException":
938
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
939
- case "ConflictingOperationException":
940
- case "com.amazonaws.workdocs#ConflictingOperationException":
941
- throw await de_ConflictingOperationExceptionRes(parsedOutput, context);
942
- case "EntityAlreadyExistsException":
943
- case "com.amazonaws.workdocs#EntityAlreadyExistsException":
944
- throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
945
- case "EntityNotExistsException":
946
- case "com.amazonaws.workdocs#EntityNotExistsException":
947
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
948
- case "FailedDependencyException":
949
- case "com.amazonaws.workdocs#FailedDependencyException":
950
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
951
- case "LimitExceededException":
952
- case "com.amazonaws.workdocs#LimitExceededException":
953
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
954
- case "ProhibitedStateException":
955
- case "com.amazonaws.workdocs#ProhibitedStateException":
956
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
957
- case "ServiceUnavailableException":
958
- case "com.amazonaws.workdocs#ServiceUnavailableException":
959
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
960
- case "UnauthorizedOperationException":
961
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
962
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
963
- case "UnauthorizedResourceAccessException":
964
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
965
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
966
- default:
967
- const parsedBody = parsedOutput.body;
968
- return throwDefaultError({
969
- output,
970
- parsedBody,
971
- errorCode,
972
- });
973
- }
974
- };
975
753
  export const de_CreateLabelsCommand = async (output, context) => {
976
754
  if (output.statusCode !== 200 && output.statusCode >= 300) {
977
- return de_CreateLabelsCommandError(output, context);
755
+ return de_CommandError(output, context);
978
756
  }
979
757
  const contents = map({
980
758
  $metadata: deserializeMetadata(output),
@@ -982,43 +760,9 @@ export const de_CreateLabelsCommand = async (output, context) => {
982
760
  await collectBody(output.body, context);
983
761
  return contents;
984
762
  };
985
- const de_CreateLabelsCommandError = async (output, context) => {
986
- const parsedOutput = {
987
- ...output,
988
- body: await parseErrorBody(output.body, context),
989
- };
990
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
991
- switch (errorCode) {
992
- case "EntityNotExistsException":
993
- case "com.amazonaws.workdocs#EntityNotExistsException":
994
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
995
- case "FailedDependencyException":
996
- case "com.amazonaws.workdocs#FailedDependencyException":
997
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
998
- case "ServiceUnavailableException":
999
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1000
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1001
- case "TooManyLabelsException":
1002
- case "com.amazonaws.workdocs#TooManyLabelsException":
1003
- throw await de_TooManyLabelsExceptionRes(parsedOutput, context);
1004
- case "UnauthorizedOperationException":
1005
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1006
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1007
- case "UnauthorizedResourceAccessException":
1008
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1009
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1010
- default:
1011
- const parsedBody = parsedOutput.body;
1012
- return throwDefaultError({
1013
- output,
1014
- parsedBody,
1015
- errorCode,
1016
- });
1017
- }
1018
- };
1019
763
  export const de_CreateNotificationSubscriptionCommand = async (output, context) => {
1020
764
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1021
- return de_CreateNotificationSubscriptionCommandError(output, context);
765
+ return de_CommandError(output, context);
1022
766
  }
1023
767
  const contents = map({
1024
768
  $metadata: deserializeMetadata(output),
@@ -1030,37 +774,9 @@ export const de_CreateNotificationSubscriptionCommand = async (output, context)
1030
774
  Object.assign(contents, doc);
1031
775
  return contents;
1032
776
  };
1033
- const de_CreateNotificationSubscriptionCommandError = async (output, context) => {
1034
- const parsedOutput = {
1035
- ...output,
1036
- body: await parseErrorBody(output.body, context),
1037
- };
1038
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1039
- switch (errorCode) {
1040
- case "InvalidArgumentException":
1041
- case "com.amazonaws.workdocs#InvalidArgumentException":
1042
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
1043
- case "ServiceUnavailableException":
1044
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1045
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1046
- case "TooManySubscriptionsException":
1047
- case "com.amazonaws.workdocs#TooManySubscriptionsException":
1048
- throw await de_TooManySubscriptionsExceptionRes(parsedOutput, context);
1049
- case "UnauthorizedResourceAccessException":
1050
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1051
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1052
- default:
1053
- const parsedBody = parsedOutput.body;
1054
- return throwDefaultError({
1055
- output,
1056
- parsedBody,
1057
- errorCode,
1058
- });
1059
- }
1060
- };
1061
777
  export const de_CreateUserCommand = async (output, context) => {
1062
778
  if (output.statusCode !== 201 && output.statusCode >= 300) {
1063
- return de_CreateUserCommandError(output, context);
779
+ return de_CommandError(output, context);
1064
780
  }
1065
781
  const contents = map({
1066
782
  $metadata: deserializeMetadata(output),
@@ -1072,40 +788,9 @@ export const de_CreateUserCommand = async (output, context) => {
1072
788
  Object.assign(contents, doc);
1073
789
  return contents;
1074
790
  };
1075
- const de_CreateUserCommandError = async (output, context) => {
1076
- const parsedOutput = {
1077
- ...output,
1078
- body: await parseErrorBody(output.body, context),
1079
- };
1080
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1081
- switch (errorCode) {
1082
- case "EntityAlreadyExistsException":
1083
- case "com.amazonaws.workdocs#EntityAlreadyExistsException":
1084
- throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
1085
- case "FailedDependencyException":
1086
- case "com.amazonaws.workdocs#FailedDependencyException":
1087
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1088
- case "ServiceUnavailableException":
1089
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1090
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1091
- case "UnauthorizedOperationException":
1092
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1093
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1094
- case "UnauthorizedResourceAccessException":
1095
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1096
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1097
- default:
1098
- const parsedBody = parsedOutput.body;
1099
- return throwDefaultError({
1100
- output,
1101
- parsedBody,
1102
- errorCode,
1103
- });
1104
- }
1105
- };
1106
791
  export const de_DeactivateUserCommand = async (output, context) => {
1107
792
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1108
- return de_DeactivateUserCommandError(output, context);
793
+ return de_CommandError(output, context);
1109
794
  }
1110
795
  const contents = map({
1111
796
  $metadata: deserializeMetadata(output),
@@ -1113,40 +798,9 @@ export const de_DeactivateUserCommand = async (output, context) => {
1113
798
  await collectBody(output.body, context);
1114
799
  return contents;
1115
800
  };
1116
- const de_DeactivateUserCommandError = async (output, context) => {
1117
- const parsedOutput = {
1118
- ...output,
1119
- body: await parseErrorBody(output.body, context),
1120
- };
1121
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1122
- switch (errorCode) {
1123
- case "EntityNotExistsException":
1124
- case "com.amazonaws.workdocs#EntityNotExistsException":
1125
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1126
- case "FailedDependencyException":
1127
- case "com.amazonaws.workdocs#FailedDependencyException":
1128
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1129
- case "ServiceUnavailableException":
1130
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1131
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1132
- case "UnauthorizedOperationException":
1133
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1134
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1135
- case "UnauthorizedResourceAccessException":
1136
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1137
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1138
- default:
1139
- const parsedBody = parsedOutput.body;
1140
- return throwDefaultError({
1141
- output,
1142
- parsedBody,
1143
- errorCode,
1144
- });
1145
- }
1146
- };
1147
801
  export const de_DeleteCommentCommand = async (output, context) => {
1148
802
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1149
- return de_DeleteCommentCommandError(output, context);
803
+ return de_CommandError(output, context);
1150
804
  }
1151
805
  const contents = map({
1152
806
  $metadata: deserializeMetadata(output),
@@ -1154,46 +808,9 @@ export const de_DeleteCommentCommand = async (output, context) => {
1154
808
  await collectBody(output.body, context);
1155
809
  return contents;
1156
810
  };
1157
- const de_DeleteCommentCommandError = async (output, context) => {
1158
- const parsedOutput = {
1159
- ...output,
1160
- body: await parseErrorBody(output.body, context),
1161
- };
1162
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1163
- switch (errorCode) {
1164
- case "DocumentLockedForCommentsException":
1165
- case "com.amazonaws.workdocs#DocumentLockedForCommentsException":
1166
- throw await de_DocumentLockedForCommentsExceptionRes(parsedOutput, context);
1167
- case "EntityNotExistsException":
1168
- case "com.amazonaws.workdocs#EntityNotExistsException":
1169
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1170
- case "FailedDependencyException":
1171
- case "com.amazonaws.workdocs#FailedDependencyException":
1172
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1173
- case "ProhibitedStateException":
1174
- case "com.amazonaws.workdocs#ProhibitedStateException":
1175
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1176
- case "ServiceUnavailableException":
1177
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1178
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1179
- case "UnauthorizedOperationException":
1180
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1181
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1182
- case "UnauthorizedResourceAccessException":
1183
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1184
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1185
- default:
1186
- const parsedBody = parsedOutput.body;
1187
- return throwDefaultError({
1188
- output,
1189
- parsedBody,
1190
- errorCode,
1191
- });
1192
- }
1193
- };
1194
811
  export const de_DeleteCustomMetadataCommand = async (output, context) => {
1195
812
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1196
- return de_DeleteCustomMetadataCommandError(output, context);
813
+ return de_CommandError(output, context);
1197
814
  }
1198
815
  const contents = map({
1199
816
  $metadata: deserializeMetadata(output),
@@ -1201,43 +818,19 @@ export const de_DeleteCustomMetadataCommand = async (output, context) => {
1201
818
  await collectBody(output.body, context);
1202
819
  return contents;
1203
820
  };
1204
- const de_DeleteCustomMetadataCommandError = async (output, context) => {
1205
- const parsedOutput = {
1206
- ...output,
1207
- body: await parseErrorBody(output.body, context),
1208
- };
1209
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1210
- switch (errorCode) {
1211
- case "EntityNotExistsException":
1212
- case "com.amazonaws.workdocs#EntityNotExistsException":
1213
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1214
- case "FailedDependencyException":
1215
- case "com.amazonaws.workdocs#FailedDependencyException":
1216
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1217
- case "ProhibitedStateException":
1218
- case "com.amazonaws.workdocs#ProhibitedStateException":
1219
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1220
- case "ServiceUnavailableException":
1221
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1222
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1223
- case "UnauthorizedOperationException":
1224
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1225
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1226
- case "UnauthorizedResourceAccessException":
1227
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1228
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1229
- default:
1230
- const parsedBody = parsedOutput.body;
1231
- return throwDefaultError({
1232
- output,
1233
- parsedBody,
1234
- errorCode,
1235
- });
821
+ export const de_DeleteDocumentCommand = async (output, context) => {
822
+ if (output.statusCode !== 204 && output.statusCode >= 300) {
823
+ return de_CommandError(output, context);
1236
824
  }
825
+ const contents = map({
826
+ $metadata: deserializeMetadata(output),
827
+ });
828
+ await collectBody(output.body, context);
829
+ return contents;
1237
830
  };
1238
- export const de_DeleteDocumentCommand = async (output, context) => {
831
+ export const de_DeleteDocumentVersionCommand = async (output, context) => {
1239
832
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1240
- return de_DeleteDocumentCommandError(output, context);
833
+ return de_CommandError(output, context);
1241
834
  }
1242
835
  const contents = map({
1243
836
  $metadata: deserializeMetadata(output),
@@ -1245,52 +838,19 @@ export const de_DeleteDocumentCommand = async (output, context) => {
1245
838
  await collectBody(output.body, context);
1246
839
  return contents;
1247
840
  };
1248
- const de_DeleteDocumentCommandError = async (output, context) => {
1249
- const parsedOutput = {
1250
- ...output,
1251
- body: await parseErrorBody(output.body, context),
1252
- };
1253
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1254
- switch (errorCode) {
1255
- case "ConcurrentModificationException":
1256
- case "com.amazonaws.workdocs#ConcurrentModificationException":
1257
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1258
- case "ConflictingOperationException":
1259
- case "com.amazonaws.workdocs#ConflictingOperationException":
1260
- throw await de_ConflictingOperationExceptionRes(parsedOutput, context);
1261
- case "EntityNotExistsException":
1262
- case "com.amazonaws.workdocs#EntityNotExistsException":
1263
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1264
- case "FailedDependencyException":
1265
- case "com.amazonaws.workdocs#FailedDependencyException":
1266
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1267
- case "LimitExceededException":
1268
- case "com.amazonaws.workdocs#LimitExceededException":
1269
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1270
- case "ProhibitedStateException":
1271
- case "com.amazonaws.workdocs#ProhibitedStateException":
1272
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1273
- case "ServiceUnavailableException":
1274
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1275
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1276
- case "UnauthorizedOperationException":
1277
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1278
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1279
- case "UnauthorizedResourceAccessException":
1280
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1281
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1282
- default:
1283
- const parsedBody = parsedOutput.body;
1284
- return throwDefaultError({
1285
- output,
1286
- parsedBody,
1287
- errorCode,
1288
- });
841
+ export const de_DeleteFolderCommand = async (output, context) => {
842
+ if (output.statusCode !== 204 && output.statusCode >= 300) {
843
+ return de_CommandError(output, context);
1289
844
  }
845
+ const contents = map({
846
+ $metadata: deserializeMetadata(output),
847
+ });
848
+ await collectBody(output.body, context);
849
+ return contents;
1290
850
  };
1291
- export const de_DeleteDocumentVersionCommand = async (output, context) => {
851
+ export const de_DeleteFolderContentsCommand = async (output, context) => {
1292
852
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1293
- return de_DeleteDocumentVersionCommandError(output, context);
853
+ return de_CommandError(output, context);
1294
854
  }
1295
855
  const contents = map({
1296
856
  $metadata: deserializeMetadata(output),
@@ -1298,49 +858,19 @@ export const de_DeleteDocumentVersionCommand = async (output, context) => {
1298
858
  await collectBody(output.body, context);
1299
859
  return contents;
1300
860
  };
1301
- const de_DeleteDocumentVersionCommandError = async (output, context) => {
1302
- const parsedOutput = {
1303
- ...output,
1304
- body: await parseErrorBody(output.body, context),
1305
- };
1306
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1307
- switch (errorCode) {
1308
- case "ConcurrentModificationException":
1309
- case "com.amazonaws.workdocs#ConcurrentModificationException":
1310
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1311
- case "ConflictingOperationException":
1312
- case "com.amazonaws.workdocs#ConflictingOperationException":
1313
- throw await de_ConflictingOperationExceptionRes(parsedOutput, context);
1314
- case "EntityNotExistsException":
1315
- case "com.amazonaws.workdocs#EntityNotExistsException":
1316
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1317
- case "FailedDependencyException":
1318
- case "com.amazonaws.workdocs#FailedDependencyException":
1319
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1320
- case "InvalidOperationException":
1321
- case "com.amazonaws.workdocs#InvalidOperationException":
1322
- throw await de_InvalidOperationExceptionRes(parsedOutput, context);
1323
- case "ProhibitedStateException":
1324
- case "com.amazonaws.workdocs#ProhibitedStateException":
1325
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1326
- case "UnauthorizedOperationException":
1327
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1328
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1329
- case "UnauthorizedResourceAccessException":
1330
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1331
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1332
- default:
1333
- const parsedBody = parsedOutput.body;
1334
- return throwDefaultError({
1335
- output,
1336
- parsedBody,
1337
- errorCode,
1338
- });
861
+ export const de_DeleteLabelsCommand = async (output, context) => {
862
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
863
+ return de_CommandError(output, context);
1339
864
  }
865
+ const contents = map({
866
+ $metadata: deserializeMetadata(output),
867
+ });
868
+ await collectBody(output.body, context);
869
+ return contents;
1340
870
  };
1341
- export const de_DeleteFolderCommand = async (output, context) => {
1342
- if (output.statusCode !== 204 && output.statusCode >= 300) {
1343
- return de_DeleteFolderCommandError(output, context);
871
+ export const de_DeleteNotificationSubscriptionCommand = async (output, context) => {
872
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
873
+ return de_CommandError(output, context);
1344
874
  }
1345
875
  const contents = map({
1346
876
  $metadata: deserializeMetadata(output),
@@ -1348,52 +878,9 @@ export const de_DeleteFolderCommand = async (output, context) => {
1348
878
  await collectBody(output.body, context);
1349
879
  return contents;
1350
880
  };
1351
- const de_DeleteFolderCommandError = async (output, context) => {
1352
- const parsedOutput = {
1353
- ...output,
1354
- body: await parseErrorBody(output.body, context),
1355
- };
1356
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1357
- switch (errorCode) {
1358
- case "ConcurrentModificationException":
1359
- case "com.amazonaws.workdocs#ConcurrentModificationException":
1360
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1361
- case "ConflictingOperationException":
1362
- case "com.amazonaws.workdocs#ConflictingOperationException":
1363
- throw await de_ConflictingOperationExceptionRes(parsedOutput, context);
1364
- case "EntityNotExistsException":
1365
- case "com.amazonaws.workdocs#EntityNotExistsException":
1366
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1367
- case "FailedDependencyException":
1368
- case "com.amazonaws.workdocs#FailedDependencyException":
1369
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1370
- case "LimitExceededException":
1371
- case "com.amazonaws.workdocs#LimitExceededException":
1372
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1373
- case "ProhibitedStateException":
1374
- case "com.amazonaws.workdocs#ProhibitedStateException":
1375
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1376
- case "ServiceUnavailableException":
1377
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1378
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1379
- case "UnauthorizedOperationException":
1380
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1381
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1382
- case "UnauthorizedResourceAccessException":
1383
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1384
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1385
- default:
1386
- const parsedBody = parsedOutput.body;
1387
- return throwDefaultError({
1388
- output,
1389
- parsedBody,
1390
- errorCode,
1391
- });
1392
- }
1393
- };
1394
- export const de_DeleteFolderContentsCommand = async (output, context) => {
881
+ export const de_DeleteUserCommand = async (output, context) => {
1395
882
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1396
- return de_DeleteFolderContentsCommandError(output, context);
883
+ return de_CommandError(output, context);
1397
884
  }
1398
885
  const contents = map({
1399
886
  $metadata: deserializeMetadata(output),
@@ -1401,843 +888,219 @@ export const de_DeleteFolderContentsCommand = async (output, context) => {
1401
888
  await collectBody(output.body, context);
1402
889
  return contents;
1403
890
  };
1404
- const de_DeleteFolderContentsCommandError = async (output, context) => {
1405
- const parsedOutput = {
1406
- ...output,
1407
- body: await parseErrorBody(output.body, context),
1408
- };
1409
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1410
- switch (errorCode) {
1411
- case "ConflictingOperationException":
1412
- case "com.amazonaws.workdocs#ConflictingOperationException":
1413
- throw await de_ConflictingOperationExceptionRes(parsedOutput, context);
1414
- case "EntityNotExistsException":
1415
- case "com.amazonaws.workdocs#EntityNotExistsException":
1416
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1417
- case "FailedDependencyException":
1418
- case "com.amazonaws.workdocs#FailedDependencyException":
1419
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1420
- case "ProhibitedStateException":
1421
- case "com.amazonaws.workdocs#ProhibitedStateException":
1422
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1423
- case "ServiceUnavailableException":
1424
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1425
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1426
- case "UnauthorizedOperationException":
1427
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1428
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1429
- case "UnauthorizedResourceAccessException":
1430
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1431
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1432
- default:
1433
- const parsedBody = parsedOutput.body;
1434
- return throwDefaultError({
1435
- output,
1436
- parsedBody,
1437
- errorCode,
1438
- });
1439
- }
1440
- };
1441
- export const de_DeleteLabelsCommand = async (output, context) => {
891
+ export const de_DescribeActivitiesCommand = async (output, context) => {
1442
892
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1443
- return de_DeleteLabelsCommandError(output, context);
893
+ return de_CommandError(output, context);
1444
894
  }
1445
895
  const contents = map({
1446
896
  $metadata: deserializeMetadata(output),
1447
897
  });
1448
- await collectBody(output.body, context);
898
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
899
+ const doc = take(data, {
900
+ Marker: __expectString,
901
+ UserActivities: (_) => de_UserActivities(_, context),
902
+ });
903
+ Object.assign(contents, doc);
1449
904
  return contents;
1450
905
  };
1451
- const de_DeleteLabelsCommandError = async (output, context) => {
1452
- const parsedOutput = {
1453
- ...output,
1454
- body: await parseErrorBody(output.body, context),
1455
- };
1456
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1457
- switch (errorCode) {
1458
- case "EntityNotExistsException":
1459
- case "com.amazonaws.workdocs#EntityNotExistsException":
1460
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1461
- case "FailedDependencyException":
1462
- case "com.amazonaws.workdocs#FailedDependencyException":
1463
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1464
- case "ProhibitedStateException":
1465
- case "com.amazonaws.workdocs#ProhibitedStateException":
1466
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1467
- case "ServiceUnavailableException":
1468
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1469
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1470
- case "UnauthorizedOperationException":
1471
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1472
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1473
- case "UnauthorizedResourceAccessException":
1474
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1475
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1476
- default:
1477
- const parsedBody = parsedOutput.body;
1478
- return throwDefaultError({
1479
- output,
1480
- parsedBody,
1481
- errorCode,
1482
- });
1483
- }
1484
- };
1485
- export const de_DeleteNotificationSubscriptionCommand = async (output, context) => {
906
+ export const de_DescribeCommentsCommand = async (output, context) => {
1486
907
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1487
- return de_DeleteNotificationSubscriptionCommandError(output, context);
908
+ return de_CommandError(output, context);
1488
909
  }
1489
910
  const contents = map({
1490
911
  $metadata: deserializeMetadata(output),
1491
912
  });
1492
- await collectBody(output.body, context);
913
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
914
+ const doc = take(data, {
915
+ Comments: (_) => de_CommentList(_, context),
916
+ Marker: __expectString,
917
+ });
918
+ Object.assign(contents, doc);
1493
919
  return contents;
1494
920
  };
1495
- const de_DeleteNotificationSubscriptionCommandError = async (output, context) => {
1496
- const parsedOutput = {
1497
- ...output,
1498
- body: await parseErrorBody(output.body, context),
1499
- };
1500
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1501
- switch (errorCode) {
1502
- case "EntityNotExistsException":
1503
- case "com.amazonaws.workdocs#EntityNotExistsException":
1504
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1505
- case "ProhibitedStateException":
1506
- case "com.amazonaws.workdocs#ProhibitedStateException":
1507
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1508
- case "ServiceUnavailableException":
1509
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1510
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1511
- case "UnauthorizedResourceAccessException":
1512
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1513
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1514
- default:
1515
- const parsedBody = parsedOutput.body;
1516
- return throwDefaultError({
1517
- output,
1518
- parsedBody,
1519
- errorCode,
1520
- });
1521
- }
1522
- };
1523
- export const de_DeleteUserCommand = async (output, context) => {
1524
- if (output.statusCode !== 204 && output.statusCode >= 300) {
1525
- return de_DeleteUserCommandError(output, context);
921
+ export const de_DescribeDocumentVersionsCommand = async (output, context) => {
922
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
923
+ return de_CommandError(output, context);
1526
924
  }
1527
925
  const contents = map({
1528
926
  $metadata: deserializeMetadata(output),
1529
927
  });
1530
- await collectBody(output.body, context);
928
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
929
+ const doc = take(data, {
930
+ DocumentVersions: (_) => de_DocumentVersionMetadataList(_, context),
931
+ Marker: __expectString,
932
+ });
933
+ Object.assign(contents, doc);
1531
934
  return contents;
1532
935
  };
1533
- const de_DeleteUserCommandError = async (output, context) => {
1534
- const parsedOutput = {
1535
- ...output,
1536
- body: await parseErrorBody(output.body, context),
1537
- };
1538
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1539
- switch (errorCode) {
1540
- case "EntityNotExistsException":
1541
- case "com.amazonaws.workdocs#EntityNotExistsException":
1542
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1543
- case "FailedDependencyException":
1544
- case "com.amazonaws.workdocs#FailedDependencyException":
1545
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1546
- case "ServiceUnavailableException":
1547
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1548
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1549
- case "UnauthorizedOperationException":
1550
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1551
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1552
- case "UnauthorizedResourceAccessException":
1553
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1554
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1555
- default:
1556
- const parsedBody = parsedOutput.body;
1557
- return throwDefaultError({
1558
- output,
1559
- parsedBody,
1560
- errorCode,
1561
- });
936
+ export const de_DescribeFolderContentsCommand = async (output, context) => {
937
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
938
+ return de_CommandError(output, context);
1562
939
  }
940
+ const contents = map({
941
+ $metadata: deserializeMetadata(output),
942
+ });
943
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
944
+ const doc = take(data, {
945
+ Documents: (_) => de_DocumentMetadataList(_, context),
946
+ Folders: (_) => de_FolderMetadataList(_, context),
947
+ Marker: __expectString,
948
+ });
949
+ Object.assign(contents, doc);
950
+ return contents;
1563
951
  };
1564
- export const de_DescribeActivitiesCommand = async (output, context) => {
952
+ export const de_DescribeGroupsCommand = async (output, context) => {
1565
953
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1566
- return de_DescribeActivitiesCommandError(output, context);
954
+ return de_CommandError(output, context);
1567
955
  }
1568
956
  const contents = map({
1569
957
  $metadata: deserializeMetadata(output),
1570
958
  });
1571
959
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1572
960
  const doc = take(data, {
961
+ Groups: _json,
1573
962
  Marker: __expectString,
1574
- UserActivities: (_) => de_UserActivities(_, context),
1575
963
  });
1576
964
  Object.assign(contents, doc);
1577
965
  return contents;
1578
966
  };
1579
- const de_DescribeActivitiesCommandError = async (output, context) => {
1580
- const parsedOutput = {
1581
- ...output,
1582
- body: await parseErrorBody(output.body, context),
1583
- };
1584
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1585
- switch (errorCode) {
1586
- case "FailedDependencyException":
1587
- case "com.amazonaws.workdocs#FailedDependencyException":
1588
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1589
- case "InvalidArgumentException":
1590
- case "com.amazonaws.workdocs#InvalidArgumentException":
1591
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
1592
- case "ServiceUnavailableException":
1593
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1594
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1595
- case "UnauthorizedOperationException":
1596
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1597
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1598
- case "UnauthorizedResourceAccessException":
1599
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1600
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1601
- default:
1602
- const parsedBody = parsedOutput.body;
1603
- return throwDefaultError({
1604
- output,
1605
- parsedBody,
1606
- errorCode,
1607
- });
967
+ export const de_DescribeNotificationSubscriptionsCommand = async (output, context) => {
968
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
969
+ return de_CommandError(output, context);
1608
970
  }
971
+ const contents = map({
972
+ $metadata: deserializeMetadata(output),
973
+ });
974
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
975
+ const doc = take(data, {
976
+ Marker: __expectString,
977
+ Subscriptions: _json,
978
+ });
979
+ Object.assign(contents, doc);
980
+ return contents;
1609
981
  };
1610
- export const de_DescribeCommentsCommand = async (output, context) => {
982
+ export const de_DescribeResourcePermissionsCommand = async (output, context) => {
1611
983
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1612
- return de_DescribeCommentsCommandError(output, context);
984
+ return de_CommandError(output, context);
1613
985
  }
1614
986
  const contents = map({
1615
987
  $metadata: deserializeMetadata(output),
1616
988
  });
1617
989
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1618
990
  const doc = take(data, {
1619
- Comments: (_) => de_CommentList(_, context),
1620
991
  Marker: __expectString,
992
+ Principals: _json,
1621
993
  });
1622
994
  Object.assign(contents, doc);
1623
995
  return contents;
1624
996
  };
1625
- const de_DescribeCommentsCommandError = 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 "EntityNotExistsException":
1633
- case "com.amazonaws.workdocs#EntityNotExistsException":
1634
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1635
- case "FailedDependencyException":
1636
- case "com.amazonaws.workdocs#FailedDependencyException":
1637
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1638
- case "ProhibitedStateException":
1639
- case "com.amazonaws.workdocs#ProhibitedStateException":
1640
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1641
- case "ServiceUnavailableException":
1642
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1643
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1644
- case "UnauthorizedOperationException":
1645
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1646
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1647
- case "UnauthorizedResourceAccessException":
1648
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1649
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1650
- default:
1651
- const parsedBody = parsedOutput.body;
1652
- return throwDefaultError({
1653
- output,
1654
- parsedBody,
1655
- errorCode,
1656
- });
1657
- }
1658
- };
1659
- export const de_DescribeDocumentVersionsCommand = async (output, context) => {
997
+ export const de_DescribeRootFoldersCommand = async (output, context) => {
1660
998
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1661
- return de_DescribeDocumentVersionsCommandError(output, context);
999
+ return de_CommandError(output, context);
1662
1000
  }
1663
1001
  const contents = map({
1664
1002
  $metadata: deserializeMetadata(output),
1665
1003
  });
1666
1004
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1667
1005
  const doc = take(data, {
1668
- DocumentVersions: (_) => de_DocumentVersionMetadataList(_, context),
1006
+ Folders: (_) => de_FolderMetadataList(_, context),
1669
1007
  Marker: __expectString,
1670
1008
  });
1671
1009
  Object.assign(contents, doc);
1672
1010
  return contents;
1673
1011
  };
1674
- const de_DescribeDocumentVersionsCommandError = async (output, context) => {
1675
- const parsedOutput = {
1676
- ...output,
1677
- body: await parseErrorBody(output.body, context),
1678
- };
1679
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1680
- switch (errorCode) {
1681
- case "EntityNotExistsException":
1682
- case "com.amazonaws.workdocs#EntityNotExistsException":
1683
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1684
- case "FailedDependencyException":
1685
- case "com.amazonaws.workdocs#FailedDependencyException":
1686
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1687
- case "InvalidArgumentException":
1688
- case "com.amazonaws.workdocs#InvalidArgumentException":
1689
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
1690
- case "InvalidPasswordException":
1691
- case "com.amazonaws.workdocs#InvalidPasswordException":
1692
- throw await de_InvalidPasswordExceptionRes(parsedOutput, context);
1693
- case "ProhibitedStateException":
1694
- case "com.amazonaws.workdocs#ProhibitedStateException":
1695
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1696
- case "ServiceUnavailableException":
1697
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1698
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1699
- case "UnauthorizedOperationException":
1700
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1701
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1702
- case "UnauthorizedResourceAccessException":
1703
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1704
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1705
- default:
1706
- const parsedBody = parsedOutput.body;
1707
- return throwDefaultError({
1708
- output,
1709
- parsedBody,
1710
- errorCode,
1711
- });
1712
- }
1713
- };
1714
- export const de_DescribeFolderContentsCommand = async (output, context) => {
1012
+ export const de_DescribeUsersCommand = async (output, context) => {
1715
1013
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1716
- return de_DescribeFolderContentsCommandError(output, context);
1014
+ return de_CommandError(output, context);
1717
1015
  }
1718
1016
  const contents = map({
1719
1017
  $metadata: deserializeMetadata(output),
1720
1018
  });
1721
1019
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1722
1020
  const doc = take(data, {
1723
- Documents: (_) => de_DocumentMetadataList(_, context),
1724
- Folders: (_) => de_FolderMetadataList(_, context),
1725
1021
  Marker: __expectString,
1022
+ TotalNumberOfUsers: __expectLong,
1023
+ Users: (_) => de_OrganizationUserList(_, context),
1726
1024
  });
1727
1025
  Object.assign(contents, doc);
1728
1026
  return contents;
1729
1027
  };
1730
- const de_DescribeFolderContentsCommandError = 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 "EntityNotExistsException":
1738
- case "com.amazonaws.workdocs#EntityNotExistsException":
1739
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1740
- case "FailedDependencyException":
1741
- case "com.amazonaws.workdocs#FailedDependencyException":
1742
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1743
- case "InvalidArgumentException":
1744
- case "com.amazonaws.workdocs#InvalidArgumentException":
1745
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
1746
- case "ProhibitedStateException":
1747
- case "com.amazonaws.workdocs#ProhibitedStateException":
1748
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
1749
- case "ServiceUnavailableException":
1750
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1751
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1752
- case "UnauthorizedResourceAccessException":
1753
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1754
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1755
- default:
1756
- const parsedBody = parsedOutput.body;
1757
- return throwDefaultError({
1758
- output,
1759
- parsedBody,
1760
- errorCode,
1761
- });
1762
- }
1763
- };
1764
- export const de_DescribeGroupsCommand = async (output, context) => {
1028
+ export const de_GetCurrentUserCommand = async (output, context) => {
1765
1029
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1766
- return de_DescribeGroupsCommandError(output, context);
1030
+ return de_CommandError(output, context);
1767
1031
  }
1768
1032
  const contents = map({
1769
1033
  $metadata: deserializeMetadata(output),
1770
1034
  });
1771
1035
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1772
1036
  const doc = take(data, {
1773
- Groups: _json,
1774
- Marker: __expectString,
1037
+ User: (_) => de_User(_, context),
1775
1038
  });
1776
1039
  Object.assign(contents, doc);
1777
1040
  return contents;
1778
1041
  };
1779
- const de_DescribeGroupsCommandError = async (output, context) => {
1780
- const parsedOutput = {
1781
- ...output,
1782
- body: await parseErrorBody(output.body, context),
1783
- };
1784
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1785
- switch (errorCode) {
1786
- case "FailedDependencyException":
1787
- case "com.amazonaws.workdocs#FailedDependencyException":
1788
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1789
- case "ServiceUnavailableException":
1790
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1791
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1792
- case "UnauthorizedOperationException":
1793
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1794
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1795
- case "UnauthorizedResourceAccessException":
1796
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1797
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1798
- default:
1799
- const parsedBody = parsedOutput.body;
1800
- return throwDefaultError({
1801
- output,
1802
- parsedBody,
1803
- errorCode,
1804
- });
1805
- }
1806
- };
1807
- export const de_DescribeNotificationSubscriptionsCommand = async (output, context) => {
1042
+ export const de_GetDocumentCommand = async (output, context) => {
1808
1043
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1809
- return de_DescribeNotificationSubscriptionsCommandError(output, context);
1044
+ return de_CommandError(output, context);
1810
1045
  }
1811
1046
  const contents = map({
1812
1047
  $metadata: deserializeMetadata(output),
1813
1048
  });
1814
1049
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1815
1050
  const doc = take(data, {
1816
- Marker: __expectString,
1817
- Subscriptions: _json,
1051
+ CustomMetadata: _json,
1052
+ Metadata: (_) => de_DocumentMetadata(_, context),
1818
1053
  });
1819
1054
  Object.assign(contents, doc);
1820
1055
  return contents;
1821
1056
  };
1822
- const de_DescribeNotificationSubscriptionsCommandError = async (output, context) => {
1823
- const parsedOutput = {
1824
- ...output,
1825
- body: await parseErrorBody(output.body, context),
1826
- };
1827
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1828
- switch (errorCode) {
1829
- case "EntityNotExistsException":
1830
- case "com.amazonaws.workdocs#EntityNotExistsException":
1831
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1832
- case "ServiceUnavailableException":
1833
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1834
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1835
- case "UnauthorizedResourceAccessException":
1836
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1837
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1838
- default:
1839
- const parsedBody = parsedOutput.body;
1840
- return throwDefaultError({
1841
- output,
1842
- parsedBody,
1843
- errorCode,
1844
- });
1845
- }
1846
- };
1847
- export const de_DescribeResourcePermissionsCommand = async (output, context) => {
1057
+ export const de_GetDocumentPathCommand = async (output, context) => {
1848
1058
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1849
- return de_DescribeResourcePermissionsCommandError(output, context);
1059
+ return de_CommandError(output, context);
1850
1060
  }
1851
1061
  const contents = map({
1852
1062
  $metadata: deserializeMetadata(output),
1853
1063
  });
1854
1064
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1855
1065
  const doc = take(data, {
1856
- Marker: __expectString,
1857
- Principals: _json,
1066
+ Path: _json,
1858
1067
  });
1859
1068
  Object.assign(contents, doc);
1860
1069
  return contents;
1861
1070
  };
1862
- const de_DescribeResourcePermissionsCommandError = async (output, context) => {
1863
- const parsedOutput = {
1864
- ...output,
1865
- body: await parseErrorBody(output.body, context),
1866
- };
1867
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1868
- switch (errorCode) {
1869
- case "FailedDependencyException":
1870
- case "com.amazonaws.workdocs#FailedDependencyException":
1871
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1872
- case "InvalidArgumentException":
1873
- case "com.amazonaws.workdocs#InvalidArgumentException":
1874
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
1875
- case "ServiceUnavailableException":
1876
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1877
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1878
- case "UnauthorizedOperationException":
1879
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1880
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1881
- case "UnauthorizedResourceAccessException":
1882
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1883
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1884
- default:
1885
- const parsedBody = parsedOutput.body;
1886
- return throwDefaultError({
1887
- output,
1888
- parsedBody,
1889
- errorCode,
1890
- });
1891
- }
1892
- };
1893
- export const de_DescribeRootFoldersCommand = async (output, context) => {
1071
+ export const de_GetDocumentVersionCommand = async (output, context) => {
1894
1072
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1895
- return de_DescribeRootFoldersCommandError(output, context);
1073
+ return de_CommandError(output, context);
1896
1074
  }
1897
1075
  const contents = map({
1898
1076
  $metadata: deserializeMetadata(output),
1899
1077
  });
1900
1078
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1901
1079
  const doc = take(data, {
1902
- Folders: (_) => de_FolderMetadataList(_, context),
1903
- Marker: __expectString,
1080
+ CustomMetadata: _json,
1081
+ Metadata: (_) => de_DocumentVersionMetadata(_, context),
1904
1082
  });
1905
1083
  Object.assign(contents, doc);
1906
1084
  return contents;
1907
1085
  };
1908
- const de_DescribeRootFoldersCommandError = async (output, context) => {
1909
- const parsedOutput = {
1910
- ...output,
1911
- body: await parseErrorBody(output.body, context),
1912
- };
1913
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1914
- switch (errorCode) {
1915
- case "FailedDependencyException":
1916
- case "com.amazonaws.workdocs#FailedDependencyException":
1917
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1918
- case "InvalidArgumentException":
1919
- case "com.amazonaws.workdocs#InvalidArgumentException":
1920
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
1921
- case "ServiceUnavailableException":
1922
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1923
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1924
- case "UnauthorizedOperationException":
1925
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1926
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1927
- case "UnauthorizedResourceAccessException":
1928
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1929
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1930
- default:
1931
- const parsedBody = parsedOutput.body;
1932
- return throwDefaultError({
1933
- output,
1934
- parsedBody,
1935
- errorCode,
1936
- });
1937
- }
1938
- };
1939
- export const de_DescribeUsersCommand = async (output, context) => {
1086
+ export const de_GetFolderCommand = async (output, context) => {
1940
1087
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1941
- return de_DescribeUsersCommandError(output, context);
1088
+ return de_CommandError(output, context);
1942
1089
  }
1943
1090
  const contents = map({
1944
1091
  $metadata: deserializeMetadata(output),
1945
1092
  });
1946
1093
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1947
1094
  const doc = take(data, {
1948
- Marker: __expectString,
1949
- TotalNumberOfUsers: __expectLong,
1950
- Users: (_) => de_OrganizationUserList(_, context),
1095
+ CustomMetadata: _json,
1096
+ Metadata: (_) => de_FolderMetadata(_, context),
1951
1097
  });
1952
1098
  Object.assign(contents, doc);
1953
1099
  return contents;
1954
1100
  };
1955
- const de_DescribeUsersCommandError = async (output, context) => {
1956
- const parsedOutput = {
1957
- ...output,
1958
- body: await parseErrorBody(output.body, context),
1959
- };
1960
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1961
- switch (errorCode) {
1962
- case "EntityNotExistsException":
1963
- case "com.amazonaws.workdocs#EntityNotExistsException":
1964
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
1965
- case "FailedDependencyException":
1966
- case "com.amazonaws.workdocs#FailedDependencyException":
1967
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
1968
- case "InvalidArgumentException":
1969
- case "com.amazonaws.workdocs#InvalidArgumentException":
1970
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
1971
- case "RequestedEntityTooLargeException":
1972
- case "com.amazonaws.workdocs#RequestedEntityTooLargeException":
1973
- throw await de_RequestedEntityTooLargeExceptionRes(parsedOutput, context);
1974
- case "ServiceUnavailableException":
1975
- case "com.amazonaws.workdocs#ServiceUnavailableException":
1976
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1977
- case "UnauthorizedOperationException":
1978
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
1979
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
1980
- case "UnauthorizedResourceAccessException":
1981
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
1982
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1983
- default:
1984
- const parsedBody = parsedOutput.body;
1985
- return throwDefaultError({
1986
- output,
1987
- parsedBody,
1988
- errorCode,
1989
- });
1990
- }
1991
- };
1992
- export const de_GetCurrentUserCommand = async (output, context) => {
1993
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1994
- return de_GetCurrentUserCommandError(output, context);
1995
- }
1996
- const contents = map({
1997
- $metadata: deserializeMetadata(output),
1998
- });
1999
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2000
- const doc = take(data, {
2001
- User: (_) => de_User(_, context),
2002
- });
2003
- Object.assign(contents, doc);
2004
- return contents;
2005
- };
2006
- const de_GetCurrentUserCommandError = async (output, context) => {
2007
- const parsedOutput = {
2008
- ...output,
2009
- body: await parseErrorBody(output.body, context),
2010
- };
2011
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2012
- switch (errorCode) {
2013
- case "EntityNotExistsException":
2014
- case "com.amazonaws.workdocs#EntityNotExistsException":
2015
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2016
- case "FailedDependencyException":
2017
- case "com.amazonaws.workdocs#FailedDependencyException":
2018
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2019
- case "ServiceUnavailableException":
2020
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2021
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2022
- case "UnauthorizedOperationException":
2023
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2024
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2025
- case "UnauthorizedResourceAccessException":
2026
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2027
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2028
- default:
2029
- const parsedBody = parsedOutput.body;
2030
- return throwDefaultError({
2031
- output,
2032
- parsedBody,
2033
- errorCode,
2034
- });
2035
- }
2036
- };
2037
- export const de_GetDocumentCommand = async (output, context) => {
2038
- if (output.statusCode !== 200 && output.statusCode >= 300) {
2039
- return de_GetDocumentCommandError(output, context);
2040
- }
2041
- const contents = map({
2042
- $metadata: deserializeMetadata(output),
2043
- });
2044
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2045
- const doc = take(data, {
2046
- CustomMetadata: _json,
2047
- Metadata: (_) => de_DocumentMetadata(_, context),
2048
- });
2049
- Object.assign(contents, doc);
2050
- return contents;
2051
- };
2052
- const de_GetDocumentCommandError = async (output, context) => {
2053
- const parsedOutput = {
2054
- ...output,
2055
- body: await parseErrorBody(output.body, context),
2056
- };
2057
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2058
- switch (errorCode) {
2059
- case "EntityNotExistsException":
2060
- case "com.amazonaws.workdocs#EntityNotExistsException":
2061
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2062
- case "FailedDependencyException":
2063
- case "com.amazonaws.workdocs#FailedDependencyException":
2064
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2065
- case "InvalidArgumentException":
2066
- case "com.amazonaws.workdocs#InvalidArgumentException":
2067
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
2068
- case "InvalidPasswordException":
2069
- case "com.amazonaws.workdocs#InvalidPasswordException":
2070
- throw await de_InvalidPasswordExceptionRes(parsedOutput, context);
2071
- case "ServiceUnavailableException":
2072
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2073
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2074
- case "UnauthorizedOperationException":
2075
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2076
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2077
- case "UnauthorizedResourceAccessException":
2078
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2079
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2080
- default:
2081
- const parsedBody = parsedOutput.body;
2082
- return throwDefaultError({
2083
- output,
2084
- parsedBody,
2085
- errorCode,
2086
- });
2087
- }
2088
- };
2089
- export const de_GetDocumentPathCommand = async (output, context) => {
2090
- if (output.statusCode !== 200 && output.statusCode >= 300) {
2091
- return de_GetDocumentPathCommandError(output, context);
2092
- }
2093
- const contents = map({
2094
- $metadata: deserializeMetadata(output),
2095
- });
2096
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2097
- const doc = take(data, {
2098
- Path: _json,
2099
- });
2100
- Object.assign(contents, doc);
2101
- return contents;
2102
- };
2103
- const de_GetDocumentPathCommandError = async (output, context) => {
2104
- const parsedOutput = {
2105
- ...output,
2106
- body: await parseErrorBody(output.body, context),
2107
- };
2108
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2109
- switch (errorCode) {
2110
- case "EntityNotExistsException":
2111
- case "com.amazonaws.workdocs#EntityNotExistsException":
2112
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2113
- case "FailedDependencyException":
2114
- case "com.amazonaws.workdocs#FailedDependencyException":
2115
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2116
- case "ServiceUnavailableException":
2117
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2118
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2119
- case "UnauthorizedOperationException":
2120
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2121
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2122
- case "UnauthorizedResourceAccessException":
2123
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2124
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2125
- default:
2126
- const parsedBody = parsedOutput.body;
2127
- return throwDefaultError({
2128
- output,
2129
- parsedBody,
2130
- errorCode,
2131
- });
2132
- }
2133
- };
2134
- export const de_GetDocumentVersionCommand = async (output, context) => {
2135
- if (output.statusCode !== 200 && output.statusCode >= 300) {
2136
- return de_GetDocumentVersionCommandError(output, context);
2137
- }
2138
- const contents = map({
2139
- $metadata: deserializeMetadata(output),
2140
- });
2141
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2142
- const doc = take(data, {
2143
- CustomMetadata: _json,
2144
- Metadata: (_) => de_DocumentVersionMetadata(_, context),
2145
- });
2146
- Object.assign(contents, doc);
2147
- return contents;
2148
- };
2149
- const de_GetDocumentVersionCommandError = async (output, context) => {
2150
- const parsedOutput = {
2151
- ...output,
2152
- body: await parseErrorBody(output.body, context),
2153
- };
2154
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2155
- switch (errorCode) {
2156
- case "EntityNotExistsException":
2157
- case "com.amazonaws.workdocs#EntityNotExistsException":
2158
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2159
- case "FailedDependencyException":
2160
- case "com.amazonaws.workdocs#FailedDependencyException":
2161
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2162
- case "InvalidPasswordException":
2163
- case "com.amazonaws.workdocs#InvalidPasswordException":
2164
- throw await de_InvalidPasswordExceptionRes(parsedOutput, context);
2165
- case "ProhibitedStateException":
2166
- case "com.amazonaws.workdocs#ProhibitedStateException":
2167
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
2168
- case "ServiceUnavailableException":
2169
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2170
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2171
- case "UnauthorizedOperationException":
2172
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2173
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2174
- case "UnauthorizedResourceAccessException":
2175
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2176
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2177
- default:
2178
- const parsedBody = parsedOutput.body;
2179
- return throwDefaultError({
2180
- output,
2181
- parsedBody,
2182
- errorCode,
2183
- });
2184
- }
2185
- };
2186
- export const de_GetFolderCommand = async (output, context) => {
2187
- if (output.statusCode !== 200 && output.statusCode >= 300) {
2188
- return de_GetFolderCommandError(output, context);
2189
- }
2190
- const contents = map({
2191
- $metadata: deserializeMetadata(output),
2192
- });
2193
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2194
- const doc = take(data, {
2195
- CustomMetadata: _json,
2196
- Metadata: (_) => de_FolderMetadata(_, context),
2197
- });
2198
- Object.assign(contents, doc);
2199
- return contents;
2200
- };
2201
- const de_GetFolderCommandError = async (output, context) => {
2202
- const parsedOutput = {
2203
- ...output,
2204
- body: await parseErrorBody(output.body, context),
2205
- };
2206
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2207
- switch (errorCode) {
2208
- case "EntityNotExistsException":
2209
- case "com.amazonaws.workdocs#EntityNotExistsException":
2210
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2211
- case "FailedDependencyException":
2212
- case "com.amazonaws.workdocs#FailedDependencyException":
2213
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2214
- case "InvalidArgumentException":
2215
- case "com.amazonaws.workdocs#InvalidArgumentException":
2216
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
2217
- case "ProhibitedStateException":
2218
- case "com.amazonaws.workdocs#ProhibitedStateException":
2219
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
2220
- case "ServiceUnavailableException":
2221
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2222
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2223
- case "UnauthorizedOperationException":
2224
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2225
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2226
- case "UnauthorizedResourceAccessException":
2227
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2228
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2229
- default:
2230
- const parsedBody = parsedOutput.body;
2231
- return throwDefaultError({
2232
- output,
2233
- parsedBody,
2234
- errorCode,
2235
- });
2236
- }
2237
- };
2238
1101
  export const de_GetFolderPathCommand = async (output, context) => {
2239
1102
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2240
- return de_GetFolderPathCommandError(output, context);
1103
+ return de_CommandError(output, context);
2241
1104
  }
2242
1105
  const contents = map({
2243
1106
  $metadata: deserializeMetadata(output),
@@ -2249,40 +1112,9 @@ export const de_GetFolderPathCommand = async (output, context) => {
2249
1112
  Object.assign(contents, doc);
2250
1113
  return contents;
2251
1114
  };
2252
- const de_GetFolderPathCommandError = async (output, context) => {
2253
- const parsedOutput = {
2254
- ...output,
2255
- body: await parseErrorBody(output.body, context),
2256
- };
2257
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2258
- switch (errorCode) {
2259
- case "EntityNotExistsException":
2260
- case "com.amazonaws.workdocs#EntityNotExistsException":
2261
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2262
- case "FailedDependencyException":
2263
- case "com.amazonaws.workdocs#FailedDependencyException":
2264
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2265
- case "ServiceUnavailableException":
2266
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2267
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2268
- case "UnauthorizedOperationException":
2269
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2270
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2271
- case "UnauthorizedResourceAccessException":
2272
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2273
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2274
- default:
2275
- const parsedBody = parsedOutput.body;
2276
- return throwDefaultError({
2277
- output,
2278
- parsedBody,
2279
- errorCode,
2280
- });
2281
- }
2282
- };
2283
1115
  export const de_GetResourcesCommand = async (output, context) => {
2284
1116
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2285
- return de_GetResourcesCommandError(output, context);
1117
+ return de_CommandError(output, context);
2286
1118
  }
2287
1119
  const contents = map({
2288
1120
  $metadata: deserializeMetadata(output),
@@ -2296,239 +1128,54 @@ export const de_GetResourcesCommand = async (output, context) => {
2296
1128
  Object.assign(contents, doc);
2297
1129
  return contents;
2298
1130
  };
2299
- const de_GetResourcesCommandError = async (output, context) => {
2300
- const parsedOutput = {
2301
- ...output,
2302
- body: await parseErrorBody(output.body, context),
2303
- };
2304
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2305
- switch (errorCode) {
2306
- case "FailedDependencyException":
2307
- case "com.amazonaws.workdocs#FailedDependencyException":
2308
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2309
- case "InvalidArgumentException":
2310
- case "com.amazonaws.workdocs#InvalidArgumentException":
2311
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
2312
- case "ServiceUnavailableException":
2313
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2314
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2315
- case "UnauthorizedOperationException":
2316
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2317
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2318
- case "UnauthorizedResourceAccessException":
2319
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2320
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2321
- default:
2322
- const parsedBody = parsedOutput.body;
2323
- return throwDefaultError({
2324
- output,
2325
- parsedBody,
2326
- errorCode,
2327
- });
2328
- }
2329
- };
2330
1131
  export const de_InitiateDocumentVersionUploadCommand = async (output, context) => {
2331
1132
  if (output.statusCode !== 201 && output.statusCode >= 300) {
2332
- return de_InitiateDocumentVersionUploadCommandError(output, context);
2333
- }
2334
- const contents = map({
2335
- $metadata: deserializeMetadata(output),
2336
- });
2337
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2338
- const doc = take(data, {
2339
- Metadata: (_) => de_DocumentMetadata(_, context),
2340
- UploadMetadata: _json,
2341
- });
2342
- Object.assign(contents, doc);
2343
- return contents;
2344
- };
2345
- const de_InitiateDocumentVersionUploadCommandError = async (output, context) => {
2346
- const parsedOutput = {
2347
- ...output,
2348
- body: await parseErrorBody(output.body, context),
2349
- };
2350
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2351
- switch (errorCode) {
2352
- case "DraftUploadOutOfSyncException":
2353
- case "com.amazonaws.workdocs#DraftUploadOutOfSyncException":
2354
- throw await de_DraftUploadOutOfSyncExceptionRes(parsedOutput, context);
2355
- case "EntityAlreadyExistsException":
2356
- case "com.amazonaws.workdocs#EntityAlreadyExistsException":
2357
- throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
2358
- case "EntityNotExistsException":
2359
- case "com.amazonaws.workdocs#EntityNotExistsException":
2360
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2361
- case "FailedDependencyException":
2362
- case "com.amazonaws.workdocs#FailedDependencyException":
2363
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2364
- case "InvalidArgumentException":
2365
- case "com.amazonaws.workdocs#InvalidArgumentException":
2366
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
2367
- case "InvalidPasswordException":
2368
- case "com.amazonaws.workdocs#InvalidPasswordException":
2369
- throw await de_InvalidPasswordExceptionRes(parsedOutput, context);
2370
- case "LimitExceededException":
2371
- case "com.amazonaws.workdocs#LimitExceededException":
2372
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2373
- case "ProhibitedStateException":
2374
- case "com.amazonaws.workdocs#ProhibitedStateException":
2375
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
2376
- case "ResourceAlreadyCheckedOutException":
2377
- case "com.amazonaws.workdocs#ResourceAlreadyCheckedOutException":
2378
- throw await de_ResourceAlreadyCheckedOutExceptionRes(parsedOutput, context);
2379
- case "ServiceUnavailableException":
2380
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2381
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2382
- case "StorageLimitExceededException":
2383
- case "com.amazonaws.workdocs#StorageLimitExceededException":
2384
- throw await de_StorageLimitExceededExceptionRes(parsedOutput, context);
2385
- case "StorageLimitWillExceedException":
2386
- case "com.amazonaws.workdocs#StorageLimitWillExceedException":
2387
- throw await de_StorageLimitWillExceedExceptionRes(parsedOutput, context);
2388
- case "UnauthorizedOperationException":
2389
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2390
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2391
- case "UnauthorizedResourceAccessException":
2392
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2393
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2394
- default:
2395
- const parsedBody = parsedOutput.body;
2396
- return throwDefaultError({
2397
- output,
2398
- parsedBody,
2399
- errorCode,
2400
- });
2401
- }
2402
- };
2403
- export const de_RemoveAllResourcePermissionsCommand = async (output, context) => {
2404
- if (output.statusCode !== 204 && output.statusCode >= 300) {
2405
- return de_RemoveAllResourcePermissionsCommandError(output, context);
2406
- }
2407
- const contents = map({
2408
- $metadata: deserializeMetadata(output),
2409
- });
2410
- await collectBody(output.body, context);
2411
- return contents;
2412
- };
2413
- const de_RemoveAllResourcePermissionsCommandError = async (output, context) => {
2414
- const parsedOutput = {
2415
- ...output,
2416
- body: await parseErrorBody(output.body, context),
2417
- };
2418
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2419
- switch (errorCode) {
2420
- case "FailedDependencyException":
2421
- case "com.amazonaws.workdocs#FailedDependencyException":
2422
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2423
- case "ServiceUnavailableException":
2424
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2425
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2426
- case "UnauthorizedOperationException":
2427
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2428
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2429
- case "UnauthorizedResourceAccessException":
2430
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2431
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2432
- default:
2433
- const parsedBody = parsedOutput.body;
2434
- return throwDefaultError({
2435
- output,
2436
- parsedBody,
2437
- errorCode,
2438
- });
2439
- }
2440
- };
2441
- export const de_RemoveResourcePermissionCommand = async (output, context) => {
2442
- if (output.statusCode !== 204 && output.statusCode >= 300) {
2443
- return de_RemoveResourcePermissionCommandError(output, context);
2444
- }
2445
- const contents = map({
2446
- $metadata: deserializeMetadata(output),
2447
- });
2448
- await collectBody(output.body, context);
2449
- return contents;
2450
- };
2451
- const de_RemoveResourcePermissionCommandError = async (output, context) => {
2452
- const parsedOutput = {
2453
- ...output,
2454
- body: await parseErrorBody(output.body, context),
2455
- };
2456
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2457
- switch (errorCode) {
2458
- case "FailedDependencyException":
2459
- case "com.amazonaws.workdocs#FailedDependencyException":
2460
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2461
- case "ServiceUnavailableException":
2462
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2463
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2464
- case "UnauthorizedOperationException":
2465
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2466
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2467
- case "UnauthorizedResourceAccessException":
2468
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2469
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2470
- default:
2471
- const parsedBody = parsedOutput.body;
2472
- return throwDefaultError({
2473
- output,
2474
- parsedBody,
2475
- errorCode,
2476
- });
2477
- }
2478
- };
2479
- export const de_RestoreDocumentVersionsCommand = async (output, context) => {
2480
- if (output.statusCode !== 204 && output.statusCode >= 300) {
2481
- return de_RestoreDocumentVersionsCommandError(output, context);
1133
+ return de_CommandError(output, context);
2482
1134
  }
2483
1135
  const contents = map({
2484
1136
  $metadata: deserializeMetadata(output),
2485
- });
2486
- await collectBody(output.body, context);
2487
- return contents;
2488
- };
2489
- const de_RestoreDocumentVersionsCommandError = async (output, context) => {
2490
- const parsedOutput = {
2491
- ...output,
2492
- body: await parseErrorBody(output.body, context),
2493
- };
2494
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2495
- switch (errorCode) {
2496
- case "ConcurrentModificationException":
2497
- case "com.amazonaws.workdocs#ConcurrentModificationException":
2498
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2499
- case "ConflictingOperationException":
2500
- case "com.amazonaws.workdocs#ConflictingOperationException":
2501
- throw await de_ConflictingOperationExceptionRes(parsedOutput, context);
2502
- case "EntityNotExistsException":
2503
- case "com.amazonaws.workdocs#EntityNotExistsException":
2504
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2505
- case "FailedDependencyException":
2506
- case "com.amazonaws.workdocs#FailedDependencyException":
2507
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2508
- case "InvalidOperationException":
2509
- case "com.amazonaws.workdocs#InvalidOperationException":
2510
- throw await de_InvalidOperationExceptionRes(parsedOutput, context);
2511
- case "ProhibitedStateException":
2512
- case "com.amazonaws.workdocs#ProhibitedStateException":
2513
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
2514
- case "UnauthorizedOperationException":
2515
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2516
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2517
- case "UnauthorizedResourceAccessException":
2518
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2519
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2520
- default:
2521
- const parsedBody = parsedOutput.body;
2522
- return throwDefaultError({
2523
- output,
2524
- parsedBody,
2525
- errorCode,
2526
- });
1137
+ });
1138
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1139
+ const doc = take(data, {
1140
+ Metadata: (_) => de_DocumentMetadata(_, context),
1141
+ UploadMetadata: _json,
1142
+ });
1143
+ Object.assign(contents, doc);
1144
+ return contents;
1145
+ };
1146
+ export const de_RemoveAllResourcePermissionsCommand = async (output, context) => {
1147
+ if (output.statusCode !== 204 && output.statusCode >= 300) {
1148
+ return de_CommandError(output, context);
1149
+ }
1150
+ const contents = map({
1151
+ $metadata: deserializeMetadata(output),
1152
+ });
1153
+ await collectBody(output.body, context);
1154
+ return contents;
1155
+ };
1156
+ export const de_RemoveResourcePermissionCommand = async (output, context) => {
1157
+ if (output.statusCode !== 204 && output.statusCode >= 300) {
1158
+ return de_CommandError(output, context);
1159
+ }
1160
+ const contents = map({
1161
+ $metadata: deserializeMetadata(output),
1162
+ });
1163
+ await collectBody(output.body, context);
1164
+ return contents;
1165
+ };
1166
+ export const de_RestoreDocumentVersionsCommand = async (output, context) => {
1167
+ if (output.statusCode !== 204 && output.statusCode >= 300) {
1168
+ return de_CommandError(output, context);
2527
1169
  }
1170
+ const contents = map({
1171
+ $metadata: deserializeMetadata(output),
1172
+ });
1173
+ await collectBody(output.body, context);
1174
+ return contents;
2528
1175
  };
2529
1176
  export const de_SearchResourcesCommand = async (output, context) => {
2530
1177
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2531
- return de_SearchResourcesCommandError(output, context);
1178
+ return de_CommandError(output, context);
2532
1179
  }
2533
1180
  const contents = map({
2534
1181
  $metadata: deserializeMetadata(output),
@@ -2541,37 +1188,9 @@ export const de_SearchResourcesCommand = async (output, context) => {
2541
1188
  Object.assign(contents, doc);
2542
1189
  return contents;
2543
1190
  };
2544
- const de_SearchResourcesCommandError = async (output, context) => {
2545
- const parsedOutput = {
2546
- ...output,
2547
- body: await parseErrorBody(output.body, context),
2548
- };
2549
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2550
- switch (errorCode) {
2551
- case "InvalidArgumentException":
2552
- case "com.amazonaws.workdocs#InvalidArgumentException":
2553
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
2554
- case "ServiceUnavailableException":
2555
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2556
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2557
- case "UnauthorizedOperationException":
2558
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2559
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2560
- case "UnauthorizedResourceAccessException":
2561
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2562
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2563
- default:
2564
- const parsedBody = parsedOutput.body;
2565
- return throwDefaultError({
2566
- output,
2567
- parsedBody,
2568
- errorCode,
2569
- });
2570
- }
2571
- };
2572
1191
  export const de_UpdateDocumentCommand = async (output, context) => {
2573
1192
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2574
- return de_UpdateDocumentCommandError(output, context);
1193
+ return de_CommandError(output, context);
2575
1194
  }
2576
1195
  const contents = map({
2577
1196
  $metadata: deserializeMetadata(output),
@@ -2579,55 +1198,9 @@ export const de_UpdateDocumentCommand = async (output, context) => {
2579
1198
  await collectBody(output.body, context);
2580
1199
  return contents;
2581
1200
  };
2582
- const de_UpdateDocumentCommandError = async (output, context) => {
2583
- const parsedOutput = {
2584
- ...output,
2585
- body: await parseErrorBody(output.body, context),
2586
- };
2587
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2588
- switch (errorCode) {
2589
- case "ConcurrentModificationException":
2590
- case "com.amazonaws.workdocs#ConcurrentModificationException":
2591
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2592
- case "ConflictingOperationException":
2593
- case "com.amazonaws.workdocs#ConflictingOperationException":
2594
- throw await de_ConflictingOperationExceptionRes(parsedOutput, context);
2595
- case "EntityAlreadyExistsException":
2596
- case "com.amazonaws.workdocs#EntityAlreadyExistsException":
2597
- throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
2598
- case "EntityNotExistsException":
2599
- case "com.amazonaws.workdocs#EntityNotExistsException":
2600
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2601
- case "FailedDependencyException":
2602
- case "com.amazonaws.workdocs#FailedDependencyException":
2603
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2604
- case "LimitExceededException":
2605
- case "com.amazonaws.workdocs#LimitExceededException":
2606
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2607
- case "ProhibitedStateException":
2608
- case "com.amazonaws.workdocs#ProhibitedStateException":
2609
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
2610
- case "ServiceUnavailableException":
2611
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2612
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2613
- case "UnauthorizedOperationException":
2614
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2615
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2616
- case "UnauthorizedResourceAccessException":
2617
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2618
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2619
- default:
2620
- const parsedBody = parsedOutput.body;
2621
- return throwDefaultError({
2622
- output,
2623
- parsedBody,
2624
- errorCode,
2625
- });
2626
- }
2627
- };
2628
1201
  export const de_UpdateDocumentVersionCommand = async (output, context) => {
2629
1202
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2630
- return de_UpdateDocumentVersionCommandError(output, context);
1203
+ return de_CommandError(output, context);
2631
1204
  }
2632
1205
  const contents = map({
2633
1206
  $metadata: deserializeMetadata(output),
@@ -2635,49 +1208,9 @@ export const de_UpdateDocumentVersionCommand = async (output, context) => {
2635
1208
  await collectBody(output.body, context);
2636
1209
  return contents;
2637
1210
  };
2638
- const de_UpdateDocumentVersionCommandError = async (output, context) => {
2639
- const parsedOutput = {
2640
- ...output,
2641
- body: await parseErrorBody(output.body, context),
2642
- };
2643
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2644
- switch (errorCode) {
2645
- case "ConcurrentModificationException":
2646
- case "com.amazonaws.workdocs#ConcurrentModificationException":
2647
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2648
- case "EntityNotExistsException":
2649
- case "com.amazonaws.workdocs#EntityNotExistsException":
2650
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2651
- case "FailedDependencyException":
2652
- case "com.amazonaws.workdocs#FailedDependencyException":
2653
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2654
- case "InvalidOperationException":
2655
- case "com.amazonaws.workdocs#InvalidOperationException":
2656
- throw await de_InvalidOperationExceptionRes(parsedOutput, context);
2657
- case "ProhibitedStateException":
2658
- case "com.amazonaws.workdocs#ProhibitedStateException":
2659
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
2660
- case "ServiceUnavailableException":
2661
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2662
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2663
- case "UnauthorizedOperationException":
2664
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2665
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2666
- case "UnauthorizedResourceAccessException":
2667
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2668
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2669
- default:
2670
- const parsedBody = parsedOutput.body;
2671
- return throwDefaultError({
2672
- output,
2673
- parsedBody,
2674
- errorCode,
2675
- });
2676
- }
2677
- };
2678
1211
  export const de_UpdateFolderCommand = async (output, context) => {
2679
1212
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2680
- return de_UpdateFolderCommandError(output, context);
1213
+ return de_CommandError(output, context);
2681
1214
  }
2682
1215
  const contents = map({
2683
1216
  $metadata: deserializeMetadata(output),
@@ -2685,55 +1218,9 @@ export const de_UpdateFolderCommand = async (output, context) => {
2685
1218
  await collectBody(output.body, context);
2686
1219
  return contents;
2687
1220
  };
2688
- const de_UpdateFolderCommandError = async (output, context) => {
2689
- const parsedOutput = {
2690
- ...output,
2691
- body: await parseErrorBody(output.body, context),
2692
- };
2693
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2694
- switch (errorCode) {
2695
- case "ConcurrentModificationException":
2696
- case "com.amazonaws.workdocs#ConcurrentModificationException":
2697
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2698
- case "ConflictingOperationException":
2699
- case "com.amazonaws.workdocs#ConflictingOperationException":
2700
- throw await de_ConflictingOperationExceptionRes(parsedOutput, context);
2701
- case "EntityAlreadyExistsException":
2702
- case "com.amazonaws.workdocs#EntityAlreadyExistsException":
2703
- throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
2704
- case "EntityNotExistsException":
2705
- case "com.amazonaws.workdocs#EntityNotExistsException":
2706
- throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2707
- case "FailedDependencyException":
2708
- case "com.amazonaws.workdocs#FailedDependencyException":
2709
- throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2710
- case "LimitExceededException":
2711
- case "com.amazonaws.workdocs#LimitExceededException":
2712
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2713
- case "ProhibitedStateException":
2714
- case "com.amazonaws.workdocs#ProhibitedStateException":
2715
- throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
2716
- case "ServiceUnavailableException":
2717
- case "com.amazonaws.workdocs#ServiceUnavailableException":
2718
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
2719
- case "UnauthorizedOperationException":
2720
- case "com.amazonaws.workdocs#UnauthorizedOperationException":
2721
- throw await de_UnauthorizedOperationExceptionRes(parsedOutput, context);
2722
- case "UnauthorizedResourceAccessException":
2723
- case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2724
- throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
2725
- default:
2726
- const parsedBody = parsedOutput.body;
2727
- return throwDefaultError({
2728
- output,
2729
- parsedBody,
2730
- errorCode,
2731
- });
2732
- }
2733
- };
2734
1221
  export const de_UpdateUserCommand = async (output, context) => {
2735
1222
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2736
- return de_UpdateUserCommandError(output, context);
1223
+ return de_CommandError(output, context);
2737
1224
  }
2738
1225
  const contents = map({
2739
1226
  $metadata: deserializeMetadata(output),
@@ -2745,28 +1232,22 @@ export const de_UpdateUserCommand = async (output, context) => {
2745
1232
  Object.assign(contents, doc);
2746
1233
  return contents;
2747
1234
  };
2748
- const de_UpdateUserCommandError = async (output, context) => {
1235
+ const de_CommandError = async (output, context) => {
2749
1236
  const parsedOutput = {
2750
1237
  ...output,
2751
1238
  body: await parseErrorBody(output.body, context),
2752
1239
  };
2753
1240
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2754
1241
  switch (errorCode) {
2755
- case "DeactivatingLastSystemUserException":
2756
- case "com.amazonaws.workdocs#DeactivatingLastSystemUserException":
2757
- throw await de_DeactivatingLastSystemUserExceptionRes(parsedOutput, context);
1242
+ case "ConcurrentModificationException":
1243
+ case "com.amazonaws.workdocs#ConcurrentModificationException":
1244
+ throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2758
1245
  case "EntityNotExistsException":
2759
1246
  case "com.amazonaws.workdocs#EntityNotExistsException":
2760
1247
  throw await de_EntityNotExistsExceptionRes(parsedOutput, context);
2761
1248
  case "FailedDependencyException":
2762
1249
  case "com.amazonaws.workdocs#FailedDependencyException":
2763
1250
  throw await de_FailedDependencyExceptionRes(parsedOutput, context);
2764
- case "IllegalUserStateException":
2765
- case "com.amazonaws.workdocs#IllegalUserStateException":
2766
- throw await de_IllegalUserStateExceptionRes(parsedOutput, context);
2767
- case "InvalidArgumentException":
2768
- case "com.amazonaws.workdocs#InvalidArgumentException":
2769
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
2770
1251
  case "ProhibitedStateException":
2771
1252
  case "com.amazonaws.workdocs#ProhibitedStateException":
2772
1253
  throw await de_ProhibitedStateExceptionRes(parsedOutput, context);
@@ -2779,6 +1260,60 @@ const de_UpdateUserCommandError = async (output, context) => {
2779
1260
  case "UnauthorizedResourceAccessException":
2780
1261
  case "com.amazonaws.workdocs#UnauthorizedResourceAccessException":
2781
1262
  throw await de_UnauthorizedResourceAccessExceptionRes(parsedOutput, context);
1263
+ case "DocumentLockedForCommentsException":
1264
+ case "com.amazonaws.workdocs#DocumentLockedForCommentsException":
1265
+ throw await de_DocumentLockedForCommentsExceptionRes(parsedOutput, context);
1266
+ case "InvalidCommentOperationException":
1267
+ case "com.amazonaws.workdocs#InvalidCommentOperationException":
1268
+ throw await de_InvalidCommentOperationExceptionRes(parsedOutput, context);
1269
+ case "CustomMetadataLimitExceededException":
1270
+ case "com.amazonaws.workdocs#CustomMetadataLimitExceededException":
1271
+ throw await de_CustomMetadataLimitExceededExceptionRes(parsedOutput, context);
1272
+ case "ConflictingOperationException":
1273
+ case "com.amazonaws.workdocs#ConflictingOperationException":
1274
+ throw await de_ConflictingOperationExceptionRes(parsedOutput, context);
1275
+ case "EntityAlreadyExistsException":
1276
+ case "com.amazonaws.workdocs#EntityAlreadyExistsException":
1277
+ throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
1278
+ case "LimitExceededException":
1279
+ case "com.amazonaws.workdocs#LimitExceededException":
1280
+ throw await de_LimitExceededExceptionRes(parsedOutput, context);
1281
+ case "TooManyLabelsException":
1282
+ case "com.amazonaws.workdocs#TooManyLabelsException":
1283
+ throw await de_TooManyLabelsExceptionRes(parsedOutput, context);
1284
+ case "InvalidArgumentException":
1285
+ case "com.amazonaws.workdocs#InvalidArgumentException":
1286
+ throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
1287
+ case "TooManySubscriptionsException":
1288
+ case "com.amazonaws.workdocs#TooManySubscriptionsException":
1289
+ throw await de_TooManySubscriptionsExceptionRes(parsedOutput, context);
1290
+ case "InvalidOperationException":
1291
+ case "com.amazonaws.workdocs#InvalidOperationException":
1292
+ throw await de_InvalidOperationExceptionRes(parsedOutput, context);
1293
+ case "InvalidPasswordException":
1294
+ case "com.amazonaws.workdocs#InvalidPasswordException":
1295
+ throw await de_InvalidPasswordExceptionRes(parsedOutput, context);
1296
+ case "RequestedEntityTooLargeException":
1297
+ case "com.amazonaws.workdocs#RequestedEntityTooLargeException":
1298
+ throw await de_RequestedEntityTooLargeExceptionRes(parsedOutput, context);
1299
+ case "DraftUploadOutOfSyncException":
1300
+ case "com.amazonaws.workdocs#DraftUploadOutOfSyncException":
1301
+ throw await de_DraftUploadOutOfSyncExceptionRes(parsedOutput, context);
1302
+ case "ResourceAlreadyCheckedOutException":
1303
+ case "com.amazonaws.workdocs#ResourceAlreadyCheckedOutException":
1304
+ throw await de_ResourceAlreadyCheckedOutExceptionRes(parsedOutput, context);
1305
+ case "StorageLimitExceededException":
1306
+ case "com.amazonaws.workdocs#StorageLimitExceededException":
1307
+ throw await de_StorageLimitExceededExceptionRes(parsedOutput, context);
1308
+ case "StorageLimitWillExceedException":
1309
+ case "com.amazonaws.workdocs#StorageLimitWillExceedException":
1310
+ throw await de_StorageLimitWillExceedExceptionRes(parsedOutput, context);
1311
+ case "DeactivatingLastSystemUserException":
1312
+ case "com.amazonaws.workdocs#DeactivatingLastSystemUserException":
1313
+ throw await de_DeactivatingLastSystemUserExceptionRes(parsedOutput, context);
1314
+ case "IllegalUserStateException":
1315
+ case "com.amazonaws.workdocs#IllegalUserStateException":
1316
+ throw await de_IllegalUserStateExceptionRes(parsedOutput, context);
2782
1317
  default:
2783
1318
  const parsedBody = parsedOutput.body;
2784
1319
  return throwDefaultError({