@aws-sdk/client-ecs 3.52.0 → 3.53.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 (16) hide show
  1. package/CHANGELOG.md +11 -0
  2. package/dist-cjs/index.js +3 -0
  3. package/dist-cjs/models/ECSServiceException.js +11 -0
  4. package/dist-cjs/models/models_0.js +319 -5
  5. package/dist-cjs/protocols/Aws_json1_1.js +627 -2138
  6. package/dist-es/index.js +1 -0
  7. package/dist-es/models/ECSServiceException.js +12 -0
  8. package/dist-es/models/models_0.js +290 -1
  9. package/dist-es/protocols/Aws_json1_1.js +1285 -2299
  10. package/dist-types/index.d.ts +1 -0
  11. package/dist-types/models/ECSServiceException.d.ts +10 -0
  12. package/dist-types/models/models_0.d.ts +170 -97
  13. package/dist-types/ts3.4/index.d.ts +1 -0
  14. package/dist-types/ts3.4/models/ECSServiceException.d.ts +6 -0
  15. package/dist-types/ts3.4/models/models_0.d.ts +122 -97
  16. package/package.json +26 -26
package/dist-cjs/protocols/Aws_json1_1.js CHANGED
@@ -5,6 +5,8 @@ exports.deserializeAws_json1_1UpdateContainerAgentCommand = exports.deserializeA
5
5
  exports.deserializeAws_json1_1UpdateTaskSetCommand = exports.deserializeAws_json1_1UpdateServicePrimaryTaskSetCommand = exports.deserializeAws_json1_1UpdateServiceCommand = exports.deserializeAws_json1_1UpdateContainerInstancesStateCommand = void 0;
6
6
  const protocol_http_1 = require("@aws-sdk/protocol-http");
7
7
  const smithy_client_1 = require("@aws-sdk/smithy-client");
8
+ const ECSServiceException_1 = require("../models/ECSServiceException");
9
+ const models_0_1 = require("../models/models_0");
8
10
  const serializeAws_json1_1CreateCapacityProviderCommand = async (input, context) => {
9
11
  const headers = {
10
12
  "content-type": "application/x-amz-json-1.1",
@@ -550,59 +552,28 @@ const deserializeAws_json1_1CreateCapacityProviderCommandError = async (output,
550
552
  switch (errorCode) {
551
553
  case "ClientException":
552
554
  case "com.amazonaws.ecs#ClientException":
553
- response = {
554
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
555
- name: errorCode,
556
- $metadata: deserializeMetadata(output),
557
- };
558
- break;
555
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
559
556
  case "InvalidParameterException":
560
557
  case "com.amazonaws.ecs#InvalidParameterException":
561
- response = {
562
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
563
- name: errorCode,
564
- $metadata: deserializeMetadata(output),
565
- };
566
- break;
558
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
567
559
  case "LimitExceededException":
568
560
  case "com.amazonaws.ecs#LimitExceededException":
569
- response = {
570
- ...(await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context)),
571
- name: errorCode,
572
- $metadata: deserializeMetadata(output),
573
- };
574
- break;
561
+ throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
575
562
  case "ServerException":
576
563
  case "com.amazonaws.ecs#ServerException":
577
- response = {
578
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
579
- name: errorCode,
580
- $metadata: deserializeMetadata(output),
581
- };
582
- break;
564
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
583
565
  case "UpdateInProgressException":
584
566
  case "com.amazonaws.ecs#UpdateInProgressException":
585
- response = {
586
- ...(await deserializeAws_json1_1UpdateInProgressExceptionResponse(parsedOutput, context)),
587
- name: errorCode,
588
- $metadata: deserializeMetadata(output),
589
- };
590
- break;
567
+ throw await deserializeAws_json1_1UpdateInProgressExceptionResponse(parsedOutput, context);
591
568
  default:
592
569
  const parsedBody = parsedOutput.body;
593
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
594
- response = {
595
- ...parsedBody,
596
- name: `${errorCode}`,
597
- message: parsedBody.message || parsedBody.Message || errorCode,
570
+ response = new ECSServiceException_1.ECSServiceException({
571
+ name: parsedBody.code || parsedBody.Code || errorCode,
598
572
  $fault: "client",
599
573
  $metadata: deserializeMetadata(output),
600
- };
574
+ });
575
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
601
576
  }
602
- const message = response.message || response.Message || errorCode;
603
- response.message = message;
604
- delete response.Message;
605
- return Promise.reject(Object.assign(new Error(message), response));
606
577
  };
607
578
  const deserializeAws_json1_1CreateClusterCommand = async (output, context) => {
608
579
  if (output.statusCode >= 300) {
@@ -629,43 +600,22 @@ const deserializeAws_json1_1CreateClusterCommandError = async (output, context)
629
600
  switch (errorCode) {
630
601
  case "ClientException":
631
602
  case "com.amazonaws.ecs#ClientException":
632
- response = {
633
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
634
- name: errorCode,
635
- $metadata: deserializeMetadata(output),
636
- };
637
- break;
603
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
638
604
  case "InvalidParameterException":
639
605
  case "com.amazonaws.ecs#InvalidParameterException":
640
- response = {
641
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
642
- name: errorCode,
643
- $metadata: deserializeMetadata(output),
644
- };
645
- break;
606
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
646
607
  case "ServerException":
647
608
  case "com.amazonaws.ecs#ServerException":
648
- response = {
649
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
650
- name: errorCode,
651
- $metadata: deserializeMetadata(output),
652
- };
653
- break;
609
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
654
610
  default:
655
611
  const parsedBody = parsedOutput.body;
656
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
657
- response = {
658
- ...parsedBody,
659
- name: `${errorCode}`,
660
- message: parsedBody.message || parsedBody.Message || errorCode,
612
+ response = new ECSServiceException_1.ECSServiceException({
613
+ name: parsedBody.code || parsedBody.Code || errorCode,
661
614
  $fault: "client",
662
615
  $metadata: deserializeMetadata(output),
663
- };
616
+ });
617
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
664
618
  }
665
- const message = response.message || response.Message || errorCode;
666
- response.message = message;
667
- delete response.Message;
668
- return Promise.reject(Object.assign(new Error(message), response));
669
619
  };
670
620
  const deserializeAws_json1_1CreateServiceCommand = async (output, context) => {
671
621
  if (output.statusCode >= 300) {
@@ -692,83 +642,37 @@ const deserializeAws_json1_1CreateServiceCommandError = async (output, context)
692
642
  switch (errorCode) {
693
643
  case "AccessDeniedException":
694
644
  case "com.amazonaws.ecs#AccessDeniedException":
695
- response = {
696
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
697
- name: errorCode,
698
- $metadata: deserializeMetadata(output),
699
- };
700
- break;
645
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
701
646
  case "ClientException":
702
647
  case "com.amazonaws.ecs#ClientException":
703
- response = {
704
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
705
- name: errorCode,
706
- $metadata: deserializeMetadata(output),
707
- };
708
- break;
648
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
709
649
  case "ClusterNotFoundException":
710
650
  case "com.amazonaws.ecs#ClusterNotFoundException":
711
- response = {
712
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
713
- name: errorCode,
714
- $metadata: deserializeMetadata(output),
715
- };
716
- break;
651
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
717
652
  case "InvalidParameterException":
718
653
  case "com.amazonaws.ecs#InvalidParameterException":
719
- response = {
720
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
721
- name: errorCode,
722
- $metadata: deserializeMetadata(output),
723
- };
724
- break;
654
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
725
655
  case "PlatformTaskDefinitionIncompatibilityException":
726
656
  case "com.amazonaws.ecs#PlatformTaskDefinitionIncompatibilityException":
727
- response = {
728
- ...(await deserializeAws_json1_1PlatformTaskDefinitionIncompatibilityExceptionResponse(parsedOutput, context)),
729
- name: errorCode,
730
- $metadata: deserializeMetadata(output),
731
- };
732
- break;
657
+ throw await deserializeAws_json1_1PlatformTaskDefinitionIncompatibilityExceptionResponse(parsedOutput, context);
733
658
  case "PlatformUnknownException":
734
659
  case "com.amazonaws.ecs#PlatformUnknownException":
735
- response = {
736
- ...(await deserializeAws_json1_1PlatformUnknownExceptionResponse(parsedOutput, context)),
737
- name: errorCode,
738
- $metadata: deserializeMetadata(output),
739
- };
740
- break;
660
+ throw await deserializeAws_json1_1PlatformUnknownExceptionResponse(parsedOutput, context);
741
661
  case "ServerException":
742
662
  case "com.amazonaws.ecs#ServerException":
743
- response = {
744
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
745
- name: errorCode,
746
- $metadata: deserializeMetadata(output),
747
- };
748
- break;
663
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
749
664
  case "UnsupportedFeatureException":
750
665
  case "com.amazonaws.ecs#UnsupportedFeatureException":
751
- response = {
752
- ...(await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context)),
753
- name: errorCode,
754
- $metadata: deserializeMetadata(output),
755
- };
756
- break;
666
+ throw await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context);
757
667
  default:
758
668
  const parsedBody = parsedOutput.body;
759
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
760
- response = {
761
- ...parsedBody,
762
- name: `${errorCode}`,
763
- message: parsedBody.message || parsedBody.Message || errorCode,
669
+ response = new ECSServiceException_1.ECSServiceException({
670
+ name: parsedBody.code || parsedBody.Code || errorCode,
764
671
  $fault: "client",
765
672
  $metadata: deserializeMetadata(output),
766
- };
673
+ });
674
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
767
675
  }
768
- const message = response.message || response.Message || errorCode;
769
- response.message = message;
770
- delete response.Message;
771
- return Promise.reject(Object.assign(new Error(message), response));
772
676
  };
773
677
  const deserializeAws_json1_1CreateTaskSetCommand = async (output, context) => {
774
678
  if (output.statusCode >= 300) {
@@ -795,99 +699,43 @@ const deserializeAws_json1_1CreateTaskSetCommandError = async (output, context)
795
699
  switch (errorCode) {
796
700
  case "AccessDeniedException":
797
701
  case "com.amazonaws.ecs#AccessDeniedException":
798
- response = {
799
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
800
- name: errorCode,
801
- $metadata: deserializeMetadata(output),
802
- };
803
- break;
702
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
804
703
  case "ClientException":
805
704
  case "com.amazonaws.ecs#ClientException":
806
- response = {
807
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
808
- name: errorCode,
809
- $metadata: deserializeMetadata(output),
810
- };
811
- break;
705
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
812
706
  case "ClusterNotFoundException":
813
707
  case "com.amazonaws.ecs#ClusterNotFoundException":
814
- response = {
815
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
816
- name: errorCode,
817
- $metadata: deserializeMetadata(output),
818
- };
819
- break;
708
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
820
709
  case "InvalidParameterException":
821
710
  case "com.amazonaws.ecs#InvalidParameterException":
822
- response = {
823
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
824
- name: errorCode,
825
- $metadata: deserializeMetadata(output),
826
- };
827
- break;
711
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
828
712
  case "PlatformTaskDefinitionIncompatibilityException":
829
713
  case "com.amazonaws.ecs#PlatformTaskDefinitionIncompatibilityException":
830
- response = {
831
- ...(await deserializeAws_json1_1PlatformTaskDefinitionIncompatibilityExceptionResponse(parsedOutput, context)),
832
- name: errorCode,
833
- $metadata: deserializeMetadata(output),
834
- };
835
- break;
714
+ throw await deserializeAws_json1_1PlatformTaskDefinitionIncompatibilityExceptionResponse(parsedOutput, context);
836
715
  case "PlatformUnknownException":
837
716
  case "com.amazonaws.ecs#PlatformUnknownException":
838
- response = {
839
- ...(await deserializeAws_json1_1PlatformUnknownExceptionResponse(parsedOutput, context)),
840
- name: errorCode,
841
- $metadata: deserializeMetadata(output),
842
- };
843
- break;
717
+ throw await deserializeAws_json1_1PlatformUnknownExceptionResponse(parsedOutput, context);
844
718
  case "ServerException":
845
719
  case "com.amazonaws.ecs#ServerException":
846
- response = {
847
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
848
- name: errorCode,
849
- $metadata: deserializeMetadata(output),
850
- };
851
- break;
720
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
852
721
  case "ServiceNotActiveException":
853
722
  case "com.amazonaws.ecs#ServiceNotActiveException":
854
- response = {
855
- ...(await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context)),
856
- name: errorCode,
857
- $metadata: deserializeMetadata(output),
858
- };
859
- break;
723
+ throw await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context);
860
724
  case "ServiceNotFoundException":
861
725
  case "com.amazonaws.ecs#ServiceNotFoundException":
862
- response = {
863
- ...(await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context)),
864
- name: errorCode,
865
- $metadata: deserializeMetadata(output),
866
- };
867
- break;
726
+ throw await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context);
868
727
  case "UnsupportedFeatureException":
869
728
  case "com.amazonaws.ecs#UnsupportedFeatureException":
870
- response = {
871
- ...(await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context)),
872
- name: errorCode,
873
- $metadata: deserializeMetadata(output),
874
- };
875
- break;
729
+ throw await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context);
876
730
  default:
877
731
  const parsedBody = parsedOutput.body;
878
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
879
- response = {
880
- ...parsedBody,
881
- name: `${errorCode}`,
882
- message: parsedBody.message || parsedBody.Message || errorCode,
732
+ response = new ECSServiceException_1.ECSServiceException({
733
+ name: parsedBody.code || parsedBody.Code || errorCode,
883
734
  $fault: "client",
884
735
  $metadata: deserializeMetadata(output),
885
- };
736
+ });
737
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
886
738
  }
887
- const message = response.message || response.Message || errorCode;
888
- response.message = message;
889
- delete response.Message;
890
- return Promise.reject(Object.assign(new Error(message), response));
891
739
  };
892
740
  const deserializeAws_json1_1DeleteAccountSettingCommand = async (output, context) => {
893
741
  if (output.statusCode >= 300) {
@@ -914,43 +762,22 @@ const deserializeAws_json1_1DeleteAccountSettingCommandError = async (output, co
914
762
  switch (errorCode) {
915
763
  case "ClientException":
916
764
  case "com.amazonaws.ecs#ClientException":
917
- response = {
918
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
919
- name: errorCode,
920
- $metadata: deserializeMetadata(output),
921
- };
922
- break;
765
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
923
766
  case "InvalidParameterException":
924
767
  case "com.amazonaws.ecs#InvalidParameterException":
925
- response = {
926
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
927
- name: errorCode,
928
- $metadata: deserializeMetadata(output),
929
- };
930
- break;
768
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
931
769
  case "ServerException":
932
770
  case "com.amazonaws.ecs#ServerException":
933
- response = {
934
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
935
- name: errorCode,
936
- $metadata: deserializeMetadata(output),
937
- };
938
- break;
771
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
939
772
  default:
940
773
  const parsedBody = parsedOutput.body;
941
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
942
- response = {
943
- ...parsedBody,
944
- name: `${errorCode}`,
945
- message: parsedBody.message || parsedBody.Message || errorCode,
774
+ response = new ECSServiceException_1.ECSServiceException({
775
+ name: parsedBody.code || parsedBody.Code || errorCode,
946
776
  $fault: "client",
947
777
  $metadata: deserializeMetadata(output),
948
- };
778
+ });
779
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
949
780
  }
950
- const message = response.message || response.Message || errorCode;
951
- response.message = message;
952
- delete response.Message;
953
- return Promise.reject(Object.assign(new Error(message), response));
954
781
  };
955
782
  const deserializeAws_json1_1DeleteAttributesCommand = async (output, context) => {
956
783
  if (output.statusCode >= 300) {
@@ -977,43 +804,22 @@ const deserializeAws_json1_1DeleteAttributesCommandError = async (output, contex
977
804
  switch (errorCode) {
978
805
  case "ClusterNotFoundException":
979
806
  case "com.amazonaws.ecs#ClusterNotFoundException":
980
- response = {
981
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
982
- name: errorCode,
983
- $metadata: deserializeMetadata(output),
984
- };
985
- break;
807
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
986
808
  case "InvalidParameterException":
987
809
  case "com.amazonaws.ecs#InvalidParameterException":
988
- response = {
989
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
990
- name: errorCode,
991
- $metadata: deserializeMetadata(output),
992
- };
993
- break;
810
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
994
811
  case "TargetNotFoundException":
995
812
  case "com.amazonaws.ecs#TargetNotFoundException":
996
- response = {
997
- ...(await deserializeAws_json1_1TargetNotFoundExceptionResponse(parsedOutput, context)),
998
- name: errorCode,
999
- $metadata: deserializeMetadata(output),
1000
- };
1001
- break;
813
+ throw await deserializeAws_json1_1TargetNotFoundExceptionResponse(parsedOutput, context);
1002
814
  default:
1003
815
  const parsedBody = parsedOutput.body;
1004
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1005
- response = {
1006
- ...parsedBody,
1007
- name: `${errorCode}`,
1008
- message: parsedBody.message || parsedBody.Message || errorCode,
816
+ response = new ECSServiceException_1.ECSServiceException({
817
+ name: parsedBody.code || parsedBody.Code || errorCode,
1009
818
  $fault: "client",
1010
819
  $metadata: deserializeMetadata(output),
1011
- };
820
+ });
821
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1012
822
  }
1013
- const message = response.message || response.Message || errorCode;
1014
- response.message = message;
1015
- delete response.Message;
1016
- return Promise.reject(Object.assign(new Error(message), response));
1017
823
  };
1018
824
  const deserializeAws_json1_1DeleteCapacityProviderCommand = async (output, context) => {
1019
825
  if (output.statusCode >= 300) {
@@ -1040,43 +846,22 @@ const deserializeAws_json1_1DeleteCapacityProviderCommandError = async (output,
1040
846
  switch (errorCode) {
1041
847
  case "ClientException":
1042
848
  case "com.amazonaws.ecs#ClientException":
1043
- response = {
1044
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1045
- name: errorCode,
1046
- $metadata: deserializeMetadata(output),
1047
- };
1048
- break;
849
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1049
850
  case "InvalidParameterException":
1050
851
  case "com.amazonaws.ecs#InvalidParameterException":
1051
- response = {
1052
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1053
- name: errorCode,
1054
- $metadata: deserializeMetadata(output),
1055
- };
1056
- break;
852
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1057
853
  case "ServerException":
1058
854
  case "com.amazonaws.ecs#ServerException":
1059
- response = {
1060
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1061
- name: errorCode,
1062
- $metadata: deserializeMetadata(output),
1063
- };
1064
- break;
855
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1065
856
  default:
1066
857
  const parsedBody = parsedOutput.body;
1067
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1068
- response = {
1069
- ...parsedBody,
1070
- name: `${errorCode}`,
1071
- message: parsedBody.message || parsedBody.Message || errorCode,
858
+ response = new ECSServiceException_1.ECSServiceException({
859
+ name: parsedBody.code || parsedBody.Code || errorCode,
1072
860
  $fault: "client",
1073
861
  $metadata: deserializeMetadata(output),
1074
- };
862
+ });
863
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1075
864
  }
1076
- const message = response.message || response.Message || errorCode;
1077
- response.message = message;
1078
- delete response.Message;
1079
- return Promise.reject(Object.assign(new Error(message), response));
1080
865
  };
1081
866
  const deserializeAws_json1_1DeleteClusterCommand = async (output, context) => {
1082
867
  if (output.statusCode >= 300) {
@@ -1103,83 +888,37 @@ const deserializeAws_json1_1DeleteClusterCommandError = async (output, context)
1103
888
  switch (errorCode) {
1104
889
  case "ClientException":
1105
890
  case "com.amazonaws.ecs#ClientException":
1106
- response = {
1107
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1108
- name: errorCode,
1109
- $metadata: deserializeMetadata(output),
1110
- };
1111
- break;
891
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1112
892
  case "ClusterContainsContainerInstancesException":
1113
893
  case "com.amazonaws.ecs#ClusterContainsContainerInstancesException":
1114
- response = {
1115
- ...(await deserializeAws_json1_1ClusterContainsContainerInstancesExceptionResponse(parsedOutput, context)),
1116
- name: errorCode,
1117
- $metadata: deserializeMetadata(output),
1118
- };
1119
- break;
894
+ throw await deserializeAws_json1_1ClusterContainsContainerInstancesExceptionResponse(parsedOutput, context);
1120
895
  case "ClusterContainsServicesException":
1121
896
  case "com.amazonaws.ecs#ClusterContainsServicesException":
1122
- response = {
1123
- ...(await deserializeAws_json1_1ClusterContainsServicesExceptionResponse(parsedOutput, context)),
1124
- name: errorCode,
1125
- $metadata: deserializeMetadata(output),
1126
- };
1127
- break;
897
+ throw await deserializeAws_json1_1ClusterContainsServicesExceptionResponse(parsedOutput, context);
1128
898
  case "ClusterContainsTasksException":
1129
899
  case "com.amazonaws.ecs#ClusterContainsTasksException":
1130
- response = {
1131
- ...(await deserializeAws_json1_1ClusterContainsTasksExceptionResponse(parsedOutput, context)),
1132
- name: errorCode,
1133
- $metadata: deserializeMetadata(output),
1134
- };
1135
- break;
900
+ throw await deserializeAws_json1_1ClusterContainsTasksExceptionResponse(parsedOutput, context);
1136
901
  case "ClusterNotFoundException":
1137
902
  case "com.amazonaws.ecs#ClusterNotFoundException":
1138
- response = {
1139
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
1140
- name: errorCode,
1141
- $metadata: deserializeMetadata(output),
1142
- };
1143
- break;
903
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
1144
904
  case "InvalidParameterException":
1145
905
  case "com.amazonaws.ecs#InvalidParameterException":
1146
- response = {
1147
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1148
- name: errorCode,
1149
- $metadata: deserializeMetadata(output),
1150
- };
1151
- break;
906
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1152
907
  case "ServerException":
1153
908
  case "com.amazonaws.ecs#ServerException":
1154
- response = {
1155
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1156
- name: errorCode,
1157
- $metadata: deserializeMetadata(output),
1158
- };
1159
- break;
909
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1160
910
  case "UpdateInProgressException":
1161
911
  case "com.amazonaws.ecs#UpdateInProgressException":
1162
- response = {
1163
- ...(await deserializeAws_json1_1UpdateInProgressExceptionResponse(parsedOutput, context)),
1164
- name: errorCode,
1165
- $metadata: deserializeMetadata(output),
1166
- };
1167
- break;
912
+ throw await deserializeAws_json1_1UpdateInProgressExceptionResponse(parsedOutput, context);
1168
913
  default:
1169
914
  const parsedBody = parsedOutput.body;
1170
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1171
- response = {
1172
- ...parsedBody,
1173
- name: `${errorCode}`,
1174
- message: parsedBody.message || parsedBody.Message || errorCode,
915
+ response = new ECSServiceException_1.ECSServiceException({
916
+ name: parsedBody.code || parsedBody.Code || errorCode,
1175
917
  $fault: "client",
1176
918
  $metadata: deserializeMetadata(output),
1177
- };
919
+ });
920
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1178
921
  }
1179
- const message = response.message || response.Message || errorCode;
1180
- response.message = message;
1181
- delete response.Message;
1182
- return Promise.reject(Object.assign(new Error(message), response));
1183
922
  };
1184
923
  const deserializeAws_json1_1DeleteServiceCommand = async (output, context) => {
1185
924
  if (output.statusCode >= 300) {
@@ -1206,59 +945,28 @@ const deserializeAws_json1_1DeleteServiceCommandError = async (output, context)
1206
945
  switch (errorCode) {
1207
946
  case "ClientException":
1208
947
  case "com.amazonaws.ecs#ClientException":
1209
- response = {
1210
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1211
- name: errorCode,
1212
- $metadata: deserializeMetadata(output),
1213
- };
1214
- break;
948
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1215
949
  case "ClusterNotFoundException":
1216
950
  case "com.amazonaws.ecs#ClusterNotFoundException":
1217
- response = {
1218
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
1219
- name: errorCode,
1220
- $metadata: deserializeMetadata(output),
1221
- };
1222
- break;
951
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
1223
952
  case "InvalidParameterException":
1224
953
  case "com.amazonaws.ecs#InvalidParameterException":
1225
- response = {
1226
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1227
- name: errorCode,
1228
- $metadata: deserializeMetadata(output),
1229
- };
1230
- break;
954
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1231
955
  case "ServerException":
1232
956
  case "com.amazonaws.ecs#ServerException":
1233
- response = {
1234
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1235
- name: errorCode,
1236
- $metadata: deserializeMetadata(output),
1237
- };
1238
- break;
957
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1239
958
  case "ServiceNotFoundException":
1240
959
  case "com.amazonaws.ecs#ServiceNotFoundException":
1241
- response = {
1242
- ...(await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context)),
1243
- name: errorCode,
1244
- $metadata: deserializeMetadata(output),
1245
- };
1246
- break;
960
+ throw await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context);
1247
961
  default:
1248
962
  const parsedBody = parsedOutput.body;
1249
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1250
- response = {
1251
- ...parsedBody,
1252
- name: `${errorCode}`,
1253
- message: parsedBody.message || parsedBody.Message || errorCode,
963
+ response = new ECSServiceException_1.ECSServiceException({
964
+ name: parsedBody.code || parsedBody.Code || errorCode,
1254
965
  $fault: "client",
1255
966
  $metadata: deserializeMetadata(output),
1256
- };
967
+ });
968
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1257
969
  }
1258
- const message = response.message || response.Message || errorCode;
1259
- response.message = message;
1260
- delete response.Message;
1261
- return Promise.reject(Object.assign(new Error(message), response));
1262
970
  };
1263
971
  const deserializeAws_json1_1DeleteTaskSetCommand = async (output, context) => {
1264
972
  if (output.statusCode >= 300) {
@@ -1285,91 +993,40 @@ const deserializeAws_json1_1DeleteTaskSetCommandError = async (output, context)
1285
993
  switch (errorCode) {
1286
994
  case "AccessDeniedException":
1287
995
  case "com.amazonaws.ecs#AccessDeniedException":
1288
- response = {
1289
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
1290
- name: errorCode,
1291
- $metadata: deserializeMetadata(output),
1292
- };
1293
- break;
996
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
1294
997
  case "ClientException":
1295
998
  case "com.amazonaws.ecs#ClientException":
1296
- response = {
1297
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1298
- name: errorCode,
1299
- $metadata: deserializeMetadata(output),
1300
- };
1301
- break;
999
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1302
1000
  case "ClusterNotFoundException":
1303
1001
  case "com.amazonaws.ecs#ClusterNotFoundException":
1304
- response = {
1305
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
1306
- name: errorCode,
1307
- $metadata: deserializeMetadata(output),
1308
- };
1309
- break;
1002
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
1310
1003
  case "InvalidParameterException":
1311
1004
  case "com.amazonaws.ecs#InvalidParameterException":
1312
- response = {
1313
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1314
- name: errorCode,
1315
- $metadata: deserializeMetadata(output),
1316
- };
1317
- break;
1005
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1318
1006
  case "ServerException":
1319
1007
  case "com.amazonaws.ecs#ServerException":
1320
- response = {
1321
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1322
- name: errorCode,
1323
- $metadata: deserializeMetadata(output),
1324
- };
1325
- break;
1008
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1326
1009
  case "ServiceNotActiveException":
1327
1010
  case "com.amazonaws.ecs#ServiceNotActiveException":
1328
- response = {
1329
- ...(await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context)),
1330
- name: errorCode,
1331
- $metadata: deserializeMetadata(output),
1332
- };
1333
- break;
1011
+ throw await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context);
1334
1012
  case "ServiceNotFoundException":
1335
1013
  case "com.amazonaws.ecs#ServiceNotFoundException":
1336
- response = {
1337
- ...(await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context)),
1338
- name: errorCode,
1339
- $metadata: deserializeMetadata(output),
1340
- };
1341
- break;
1014
+ throw await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context);
1342
1015
  case "TaskSetNotFoundException":
1343
1016
  case "com.amazonaws.ecs#TaskSetNotFoundException":
1344
- response = {
1345
- ...(await deserializeAws_json1_1TaskSetNotFoundExceptionResponse(parsedOutput, context)),
1346
- name: errorCode,
1347
- $metadata: deserializeMetadata(output),
1348
- };
1349
- break;
1017
+ throw await deserializeAws_json1_1TaskSetNotFoundExceptionResponse(parsedOutput, context);
1350
1018
  case "UnsupportedFeatureException":
1351
1019
  case "com.amazonaws.ecs#UnsupportedFeatureException":
1352
- response = {
1353
- ...(await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context)),
1354
- name: errorCode,
1355
- $metadata: deserializeMetadata(output),
1356
- };
1357
- break;
1020
+ throw await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context);
1358
1021
  default:
1359
1022
  const parsedBody = parsedOutput.body;
1360
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1361
- response = {
1362
- ...parsedBody,
1363
- name: `${errorCode}`,
1364
- message: parsedBody.message || parsedBody.Message || errorCode,
1023
+ response = new ECSServiceException_1.ECSServiceException({
1024
+ name: parsedBody.code || parsedBody.Code || errorCode,
1365
1025
  $fault: "client",
1366
1026
  $metadata: deserializeMetadata(output),
1367
- };
1027
+ });
1028
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1368
1029
  }
1369
- const message = response.message || response.Message || errorCode;
1370
- response.message = message;
1371
- delete response.Message;
1372
- return Promise.reject(Object.assign(new Error(message), response));
1373
1030
  };
1374
1031
  const deserializeAws_json1_1DeregisterContainerInstanceCommand = async (output, context) => {
1375
1032
  if (output.statusCode >= 300) {
@@ -1396,51 +1053,25 @@ const deserializeAws_json1_1DeregisterContainerInstanceCommandError = async (out
1396
1053
  switch (errorCode) {
1397
1054
  case "ClientException":
1398
1055
  case "com.amazonaws.ecs#ClientException":
1399
- response = {
1400
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1401
- name: errorCode,
1402
- $metadata: deserializeMetadata(output),
1403
- };
1404
- break;
1056
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1405
1057
  case "ClusterNotFoundException":
1406
1058
  case "com.amazonaws.ecs#ClusterNotFoundException":
1407
- response = {
1408
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
1409
- name: errorCode,
1410
- $metadata: deserializeMetadata(output),
1411
- };
1412
- break;
1059
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
1413
1060
  case "InvalidParameterException":
1414
1061
  case "com.amazonaws.ecs#InvalidParameterException":
1415
- response = {
1416
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1417
- name: errorCode,
1418
- $metadata: deserializeMetadata(output),
1419
- };
1420
- break;
1062
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1421
1063
  case "ServerException":
1422
1064
  case "com.amazonaws.ecs#ServerException":
1423
- response = {
1424
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1425
- name: errorCode,
1426
- $metadata: deserializeMetadata(output),
1427
- };
1428
- break;
1065
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1429
1066
  default:
1430
1067
  const parsedBody = parsedOutput.body;
1431
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1432
- response = {
1433
- ...parsedBody,
1434
- name: `${errorCode}`,
1435
- message: parsedBody.message || parsedBody.Message || errorCode,
1068
+ response = new ECSServiceException_1.ECSServiceException({
1069
+ name: parsedBody.code || parsedBody.Code || errorCode,
1436
1070
  $fault: "client",
1437
1071
  $metadata: deserializeMetadata(output),
1438
- };
1072
+ });
1073
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1439
1074
  }
1440
- const message = response.message || response.Message || errorCode;
1441
- response.message = message;
1442
- delete response.Message;
1443
- return Promise.reject(Object.assign(new Error(message), response));
1444
1075
  };
1445
1076
  const deserializeAws_json1_1DeregisterTaskDefinitionCommand = async (output, context) => {
1446
1077
  if (output.statusCode >= 300) {
@@ -1467,43 +1098,22 @@ const deserializeAws_json1_1DeregisterTaskDefinitionCommandError = async (output
1467
1098
  switch (errorCode) {
1468
1099
  case "ClientException":
1469
1100
  case "com.amazonaws.ecs#ClientException":
1470
- response = {
1471
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1472
- name: errorCode,
1473
- $metadata: deserializeMetadata(output),
1474
- };
1475
- break;
1101
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1476
1102
  case "InvalidParameterException":
1477
1103
  case "com.amazonaws.ecs#InvalidParameterException":
1478
- response = {
1479
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1480
- name: errorCode,
1481
- $metadata: deserializeMetadata(output),
1482
- };
1483
- break;
1104
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1484
1105
  case "ServerException":
1485
1106
  case "com.amazonaws.ecs#ServerException":
1486
- response = {
1487
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1488
- name: errorCode,
1489
- $metadata: deserializeMetadata(output),
1490
- };
1491
- break;
1107
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1492
1108
  default:
1493
1109
  const parsedBody = parsedOutput.body;
1494
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1495
- response = {
1496
- ...parsedBody,
1497
- name: `${errorCode}`,
1498
- message: parsedBody.message || parsedBody.Message || errorCode,
1110
+ response = new ECSServiceException_1.ECSServiceException({
1111
+ name: parsedBody.code || parsedBody.Code || errorCode,
1499
1112
  $fault: "client",
1500
1113
  $metadata: deserializeMetadata(output),
1501
- };
1114
+ });
1115
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1502
1116
  }
1503
- const message = response.message || response.Message || errorCode;
1504
- response.message = message;
1505
- delete response.Message;
1506
- return Promise.reject(Object.assign(new Error(message), response));
1507
1117
  };
1508
1118
  const deserializeAws_json1_1DescribeCapacityProvidersCommand = async (output, context) => {
1509
1119
  if (output.statusCode >= 300) {
@@ -1530,43 +1140,22 @@ const deserializeAws_json1_1DescribeCapacityProvidersCommandError = async (outpu
1530
1140
  switch (errorCode) {
1531
1141
  case "ClientException":
1532
1142
  case "com.amazonaws.ecs#ClientException":
1533
- response = {
1534
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1535
- name: errorCode,
1536
- $metadata: deserializeMetadata(output),
1537
- };
1538
- break;
1143
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1539
1144
  case "InvalidParameterException":
1540
1145
  case "com.amazonaws.ecs#InvalidParameterException":
1541
- response = {
1542
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1543
- name: errorCode,
1544
- $metadata: deserializeMetadata(output),
1545
- };
1546
- break;
1146
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1547
1147
  case "ServerException":
1548
1148
  case "com.amazonaws.ecs#ServerException":
1549
- response = {
1550
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1551
- name: errorCode,
1552
- $metadata: deserializeMetadata(output),
1553
- };
1554
- break;
1149
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1555
1150
  default:
1556
1151
  const parsedBody = parsedOutput.body;
1557
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1558
- response = {
1559
- ...parsedBody,
1560
- name: `${errorCode}`,
1561
- message: parsedBody.message || parsedBody.Message || errorCode,
1152
+ response = new ECSServiceException_1.ECSServiceException({
1153
+ name: parsedBody.code || parsedBody.Code || errorCode,
1562
1154
  $fault: "client",
1563
1155
  $metadata: deserializeMetadata(output),
1564
- };
1156
+ });
1157
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1565
1158
  }
1566
- const message = response.message || response.Message || errorCode;
1567
- response.message = message;
1568
- delete response.Message;
1569
- return Promise.reject(Object.assign(new Error(message), response));
1570
1159
  };
1571
1160
  const deserializeAws_json1_1DescribeClustersCommand = async (output, context) => {
1572
1161
  if (output.statusCode >= 300) {
@@ -1593,43 +1182,22 @@ const deserializeAws_json1_1DescribeClustersCommandError = async (output, contex
1593
1182
  switch (errorCode) {
1594
1183
  case "ClientException":
1595
1184
  case "com.amazonaws.ecs#ClientException":
1596
- response = {
1597
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1598
- name: errorCode,
1599
- $metadata: deserializeMetadata(output),
1600
- };
1601
- break;
1185
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1602
1186
  case "InvalidParameterException":
1603
1187
  case "com.amazonaws.ecs#InvalidParameterException":
1604
- response = {
1605
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1606
- name: errorCode,
1607
- $metadata: deserializeMetadata(output),
1608
- };
1609
- break;
1188
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1610
1189
  case "ServerException":
1611
1190
  case "com.amazonaws.ecs#ServerException":
1612
- response = {
1613
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1614
- name: errorCode,
1615
- $metadata: deserializeMetadata(output),
1616
- };
1617
- break;
1191
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1618
1192
  default:
1619
1193
  const parsedBody = parsedOutput.body;
1620
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1621
- response = {
1622
- ...parsedBody,
1623
- name: `${errorCode}`,
1624
- message: parsedBody.message || parsedBody.Message || errorCode,
1194
+ response = new ECSServiceException_1.ECSServiceException({
1195
+ name: parsedBody.code || parsedBody.Code || errorCode,
1625
1196
  $fault: "client",
1626
1197
  $metadata: deserializeMetadata(output),
1627
- };
1198
+ });
1199
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1628
1200
  }
1629
- const message = response.message || response.Message || errorCode;
1630
- response.message = message;
1631
- delete response.Message;
1632
- return Promise.reject(Object.assign(new Error(message), response));
1633
1201
  };
1634
1202
  const deserializeAws_json1_1DescribeContainerInstancesCommand = async (output, context) => {
1635
1203
  if (output.statusCode >= 300) {
@@ -1656,51 +1224,25 @@ const deserializeAws_json1_1DescribeContainerInstancesCommandError = async (outp
1656
1224
  switch (errorCode) {
1657
1225
  case "ClientException":
1658
1226
  case "com.amazonaws.ecs#ClientException":
1659
- response = {
1660
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1661
- name: errorCode,
1662
- $metadata: deserializeMetadata(output),
1663
- };
1664
- break;
1227
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1665
1228
  case "ClusterNotFoundException":
1666
1229
  case "com.amazonaws.ecs#ClusterNotFoundException":
1667
- response = {
1668
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
1669
- name: errorCode,
1670
- $metadata: deserializeMetadata(output),
1671
- };
1672
- break;
1230
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
1673
1231
  case "InvalidParameterException":
1674
1232
  case "com.amazonaws.ecs#InvalidParameterException":
1675
- response = {
1676
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1677
- name: errorCode,
1678
- $metadata: deserializeMetadata(output),
1679
- };
1680
- break;
1233
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1681
1234
  case "ServerException":
1682
1235
  case "com.amazonaws.ecs#ServerException":
1683
- response = {
1684
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1685
- name: errorCode,
1686
- $metadata: deserializeMetadata(output),
1687
- };
1688
- break;
1236
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1689
1237
  default:
1690
1238
  const parsedBody = parsedOutput.body;
1691
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1692
- response = {
1693
- ...parsedBody,
1694
- name: `${errorCode}`,
1695
- message: parsedBody.message || parsedBody.Message || errorCode,
1239
+ response = new ECSServiceException_1.ECSServiceException({
1240
+ name: parsedBody.code || parsedBody.Code || errorCode,
1696
1241
  $fault: "client",
1697
1242
  $metadata: deserializeMetadata(output),
1698
- };
1243
+ });
1244
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1699
1245
  }
1700
- const message = response.message || response.Message || errorCode;
1701
- response.message = message;
1702
- delete response.Message;
1703
- return Promise.reject(Object.assign(new Error(message), response));
1704
1246
  };
1705
1247
  const deserializeAws_json1_1DescribeServicesCommand = async (output, context) => {
1706
1248
  if (output.statusCode >= 300) {
@@ -1727,51 +1269,25 @@ const deserializeAws_json1_1DescribeServicesCommandError = async (output, contex
1727
1269
  switch (errorCode) {
1728
1270
  case "ClientException":
1729
1271
  case "com.amazonaws.ecs#ClientException":
1730
- response = {
1731
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1732
- name: errorCode,
1733
- $metadata: deserializeMetadata(output),
1734
- };
1735
- break;
1272
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1736
1273
  case "ClusterNotFoundException":
1737
1274
  case "com.amazonaws.ecs#ClusterNotFoundException":
1738
- response = {
1739
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
1740
- name: errorCode,
1741
- $metadata: deserializeMetadata(output),
1742
- };
1743
- break;
1275
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
1744
1276
  case "InvalidParameterException":
1745
1277
  case "com.amazonaws.ecs#InvalidParameterException":
1746
- response = {
1747
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1748
- name: errorCode,
1749
- $metadata: deserializeMetadata(output),
1750
- };
1751
- break;
1278
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1752
1279
  case "ServerException":
1753
1280
  case "com.amazonaws.ecs#ServerException":
1754
- response = {
1755
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1756
- name: errorCode,
1757
- $metadata: deserializeMetadata(output),
1758
- };
1759
- break;
1281
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1760
1282
  default:
1761
1283
  const parsedBody = parsedOutput.body;
1762
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1763
- response = {
1764
- ...parsedBody,
1765
- name: `${errorCode}`,
1766
- message: parsedBody.message || parsedBody.Message || errorCode,
1284
+ response = new ECSServiceException_1.ECSServiceException({
1285
+ name: parsedBody.code || parsedBody.Code || errorCode,
1767
1286
  $fault: "client",
1768
1287
  $metadata: deserializeMetadata(output),
1769
- };
1288
+ });
1289
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1770
1290
  }
1771
- const message = response.message || response.Message || errorCode;
1772
- response.message = message;
1773
- delete response.Message;
1774
- return Promise.reject(Object.assign(new Error(message), response));
1775
1291
  };
1776
1292
  const deserializeAws_json1_1DescribeTaskDefinitionCommand = async (output, context) => {
1777
1293
  if (output.statusCode >= 300) {
@@ -1798,43 +1314,22 @@ const deserializeAws_json1_1DescribeTaskDefinitionCommandError = async (output,
1798
1314
  switch (errorCode) {
1799
1315
  case "ClientException":
1800
1316
  case "com.amazonaws.ecs#ClientException":
1801
- response = {
1802
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1803
- name: errorCode,
1804
- $metadata: deserializeMetadata(output),
1805
- };
1806
- break;
1317
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1807
1318
  case "InvalidParameterException":
1808
1319
  case "com.amazonaws.ecs#InvalidParameterException":
1809
- response = {
1810
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1811
- name: errorCode,
1812
- $metadata: deserializeMetadata(output),
1813
- };
1814
- break;
1320
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1815
1321
  case "ServerException":
1816
1322
  case "com.amazonaws.ecs#ServerException":
1817
- response = {
1818
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1819
- name: errorCode,
1820
- $metadata: deserializeMetadata(output),
1821
- };
1822
- break;
1323
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1823
1324
  default:
1824
1325
  const parsedBody = parsedOutput.body;
1825
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1826
- response = {
1827
- ...parsedBody,
1828
- name: `${errorCode}`,
1829
- message: parsedBody.message || parsedBody.Message || errorCode,
1326
+ response = new ECSServiceException_1.ECSServiceException({
1327
+ name: parsedBody.code || parsedBody.Code || errorCode,
1830
1328
  $fault: "client",
1831
1329
  $metadata: deserializeMetadata(output),
1832
- };
1330
+ });
1331
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1833
1332
  }
1834
- const message = response.message || response.Message || errorCode;
1835
- response.message = message;
1836
- delete response.Message;
1837
- return Promise.reject(Object.assign(new Error(message), response));
1838
1333
  };
1839
1334
  const deserializeAws_json1_1DescribeTasksCommand = async (output, context) => {
1840
1335
  if (output.statusCode >= 300) {
@@ -1861,51 +1356,25 @@ const deserializeAws_json1_1DescribeTasksCommandError = async (output, context)
1861
1356
  switch (errorCode) {
1862
1357
  case "ClientException":
1863
1358
  case "com.amazonaws.ecs#ClientException":
1864
- response = {
1865
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1866
- name: errorCode,
1867
- $metadata: deserializeMetadata(output),
1868
- };
1869
- break;
1359
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1870
1360
  case "ClusterNotFoundException":
1871
1361
  case "com.amazonaws.ecs#ClusterNotFoundException":
1872
- response = {
1873
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
1874
- name: errorCode,
1875
- $metadata: deserializeMetadata(output),
1876
- };
1877
- break;
1362
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
1878
1363
  case "InvalidParameterException":
1879
1364
  case "com.amazonaws.ecs#InvalidParameterException":
1880
- response = {
1881
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1882
- name: errorCode,
1883
- $metadata: deserializeMetadata(output),
1884
- };
1885
- break;
1365
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1886
1366
  case "ServerException":
1887
1367
  case "com.amazonaws.ecs#ServerException":
1888
- response = {
1889
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1890
- name: errorCode,
1891
- $metadata: deserializeMetadata(output),
1892
- };
1893
- break;
1368
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1894
1369
  default:
1895
1370
  const parsedBody = parsedOutput.body;
1896
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1897
- response = {
1898
- ...parsedBody,
1899
- name: `${errorCode}`,
1900
- message: parsedBody.message || parsedBody.Message || errorCode,
1371
+ response = new ECSServiceException_1.ECSServiceException({
1372
+ name: parsedBody.code || parsedBody.Code || errorCode,
1901
1373
  $fault: "client",
1902
1374
  $metadata: deserializeMetadata(output),
1903
- };
1375
+ });
1376
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1904
1377
  }
1905
- const message = response.message || response.Message || errorCode;
1906
- response.message = message;
1907
- delete response.Message;
1908
- return Promise.reject(Object.assign(new Error(message), response));
1909
1378
  };
1910
1379
  const deserializeAws_json1_1DescribeTaskSetsCommand = async (output, context) => {
1911
1380
  if (output.statusCode >= 300) {
@@ -1932,83 +1401,37 @@ const deserializeAws_json1_1DescribeTaskSetsCommandError = async (output, contex
1932
1401
  switch (errorCode) {
1933
1402
  case "AccessDeniedException":
1934
1403
  case "com.amazonaws.ecs#AccessDeniedException":
1935
- response = {
1936
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
1937
- name: errorCode,
1938
- $metadata: deserializeMetadata(output),
1939
- };
1940
- break;
1404
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
1941
1405
  case "ClientException":
1942
1406
  case "com.amazonaws.ecs#ClientException":
1943
- response = {
1944
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
1945
- name: errorCode,
1946
- $metadata: deserializeMetadata(output),
1947
- };
1948
- break;
1407
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
1949
1408
  case "ClusterNotFoundException":
1950
1409
  case "com.amazonaws.ecs#ClusterNotFoundException":
1951
- response = {
1952
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
1953
- name: errorCode,
1954
- $metadata: deserializeMetadata(output),
1955
- };
1956
- break;
1410
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
1957
1411
  case "InvalidParameterException":
1958
1412
  case "com.amazonaws.ecs#InvalidParameterException":
1959
- response = {
1960
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
1961
- name: errorCode,
1962
- $metadata: deserializeMetadata(output),
1963
- };
1964
- break;
1413
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
1965
1414
  case "ServerException":
1966
1415
  case "com.amazonaws.ecs#ServerException":
1967
- response = {
1968
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
1969
- name: errorCode,
1970
- $metadata: deserializeMetadata(output),
1971
- };
1972
- break;
1416
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
1973
1417
  case "ServiceNotActiveException":
1974
1418
  case "com.amazonaws.ecs#ServiceNotActiveException":
1975
- response = {
1976
- ...(await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context)),
1977
- name: errorCode,
1978
- $metadata: deserializeMetadata(output),
1979
- };
1980
- break;
1419
+ throw await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context);
1981
1420
  case "ServiceNotFoundException":
1982
1421
  case "com.amazonaws.ecs#ServiceNotFoundException":
1983
- response = {
1984
- ...(await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context)),
1985
- name: errorCode,
1986
- $metadata: deserializeMetadata(output),
1987
- };
1988
- break;
1422
+ throw await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context);
1989
1423
  case "UnsupportedFeatureException":
1990
1424
  case "com.amazonaws.ecs#UnsupportedFeatureException":
1991
- response = {
1992
- ...(await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context)),
1993
- name: errorCode,
1994
- $metadata: deserializeMetadata(output),
1995
- };
1996
- break;
1425
+ throw await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context);
1997
1426
  default:
1998
1427
  const parsedBody = parsedOutput.body;
1999
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2000
- response = {
2001
- ...parsedBody,
2002
- name: `${errorCode}`,
2003
- message: parsedBody.message || parsedBody.Message || errorCode,
1428
+ response = new ECSServiceException_1.ECSServiceException({
1429
+ name: parsedBody.code || parsedBody.Code || errorCode,
2004
1430
  $fault: "client",
2005
1431
  $metadata: deserializeMetadata(output),
2006
- };
1432
+ });
1433
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2007
1434
  }
2008
- const message = response.message || response.Message || errorCode;
2009
- response.message = message;
2010
- delete response.Message;
2011
- return Promise.reject(Object.assign(new Error(message), response));
2012
1435
  };
2013
1436
  const deserializeAws_json1_1DiscoverPollEndpointCommand = async (output, context) => {
2014
1437
  if (output.statusCode >= 300) {
@@ -2035,35 +1458,19 @@ const deserializeAws_json1_1DiscoverPollEndpointCommandError = async (output, co
2035
1458
  switch (errorCode) {
2036
1459
  case "ClientException":
2037
1460
  case "com.amazonaws.ecs#ClientException":
2038
- response = {
2039
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2040
- name: errorCode,
2041
- $metadata: deserializeMetadata(output),
2042
- };
2043
- break;
1461
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2044
1462
  case "ServerException":
2045
1463
  case "com.amazonaws.ecs#ServerException":
2046
- response = {
2047
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2048
- name: errorCode,
2049
- $metadata: deserializeMetadata(output),
2050
- };
2051
- break;
1464
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2052
1465
  default:
2053
1466
  const parsedBody = parsedOutput.body;
2054
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2055
- response = {
2056
- ...parsedBody,
2057
- name: `${errorCode}`,
2058
- message: parsedBody.message || parsedBody.Message || errorCode,
1467
+ response = new ECSServiceException_1.ECSServiceException({
1468
+ name: parsedBody.code || parsedBody.Code || errorCode,
2059
1469
  $fault: "client",
2060
1470
  $metadata: deserializeMetadata(output),
2061
- };
1471
+ });
1472
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2062
1473
  }
2063
- const message = response.message || response.Message || errorCode;
2064
- response.message = message;
2065
- delete response.Message;
2066
- return Promise.reject(Object.assign(new Error(message), response));
2067
1474
  };
2068
1475
  const deserializeAws_json1_1ExecuteCommandCommand = async (output, context) => {
2069
1476
  if (output.statusCode >= 300) {
@@ -2090,67 +1497,31 @@ const deserializeAws_json1_1ExecuteCommandCommandError = async (output, context)
2090
1497
  switch (errorCode) {
2091
1498
  case "AccessDeniedException":
2092
1499
  case "com.amazonaws.ecs#AccessDeniedException":
2093
- response = {
2094
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
2095
- name: errorCode,
2096
- $metadata: deserializeMetadata(output),
2097
- };
2098
- break;
1500
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
2099
1501
  case "ClientException":
2100
1502
  case "com.amazonaws.ecs#ClientException":
2101
- response = {
2102
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2103
- name: errorCode,
2104
- $metadata: deserializeMetadata(output),
2105
- };
2106
- break;
1503
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2107
1504
  case "ClusterNotFoundException":
2108
1505
  case "com.amazonaws.ecs#ClusterNotFoundException":
2109
- response = {
2110
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
2111
- name: errorCode,
2112
- $metadata: deserializeMetadata(output),
2113
- };
2114
- break;
1506
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
2115
1507
  case "InvalidParameterException":
2116
1508
  case "com.amazonaws.ecs#InvalidParameterException":
2117
- response = {
2118
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2119
- name: errorCode,
2120
- $metadata: deserializeMetadata(output),
2121
- };
2122
- break;
1509
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2123
1510
  case "ServerException":
2124
1511
  case "com.amazonaws.ecs#ServerException":
2125
- response = {
2126
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2127
- name: errorCode,
2128
- $metadata: deserializeMetadata(output),
2129
- };
2130
- break;
1512
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2131
1513
  case "TargetNotConnectedException":
2132
1514
  case "com.amazonaws.ecs#TargetNotConnectedException":
2133
- response = {
2134
- ...(await deserializeAws_json1_1TargetNotConnectedExceptionResponse(parsedOutput, context)),
2135
- name: errorCode,
2136
- $metadata: deserializeMetadata(output),
2137
- };
2138
- break;
1515
+ throw await deserializeAws_json1_1TargetNotConnectedExceptionResponse(parsedOutput, context);
2139
1516
  default:
2140
1517
  const parsedBody = parsedOutput.body;
2141
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2142
- response = {
2143
- ...parsedBody,
2144
- name: `${errorCode}`,
2145
- message: parsedBody.message || parsedBody.Message || errorCode,
1518
+ response = new ECSServiceException_1.ECSServiceException({
1519
+ name: parsedBody.code || parsedBody.Code || errorCode,
2146
1520
  $fault: "client",
2147
1521
  $metadata: deserializeMetadata(output),
2148
- };
1522
+ });
1523
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2149
1524
  }
2150
- const message = response.message || response.Message || errorCode;
2151
- response.message = message;
2152
- delete response.Message;
2153
- return Promise.reject(Object.assign(new Error(message), response));
2154
1525
  };
2155
1526
  const deserializeAws_json1_1ListAccountSettingsCommand = async (output, context) => {
2156
1527
  if (output.statusCode >= 300) {
@@ -2177,43 +1548,22 @@ const deserializeAws_json1_1ListAccountSettingsCommandError = async (output, con
2177
1548
  switch (errorCode) {
2178
1549
  case "ClientException":
2179
1550
  case "com.amazonaws.ecs#ClientException":
2180
- response = {
2181
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2182
- name: errorCode,
2183
- $metadata: deserializeMetadata(output),
2184
- };
2185
- break;
1551
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2186
1552
  case "InvalidParameterException":
2187
1553
  case "com.amazonaws.ecs#InvalidParameterException":
2188
- response = {
2189
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2190
- name: errorCode,
2191
- $metadata: deserializeMetadata(output),
2192
- };
2193
- break;
1554
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2194
1555
  case "ServerException":
2195
1556
  case "com.amazonaws.ecs#ServerException":
2196
- response = {
2197
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2198
- name: errorCode,
2199
- $metadata: deserializeMetadata(output),
2200
- };
2201
- break;
1557
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2202
1558
  default:
2203
1559
  const parsedBody = parsedOutput.body;
2204
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2205
- response = {
2206
- ...parsedBody,
2207
- name: `${errorCode}`,
2208
- message: parsedBody.message || parsedBody.Message || errorCode,
1560
+ response = new ECSServiceException_1.ECSServiceException({
1561
+ name: parsedBody.code || parsedBody.Code || errorCode,
2209
1562
  $fault: "client",
2210
1563
  $metadata: deserializeMetadata(output),
2211
- };
1564
+ });
1565
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2212
1566
  }
2213
- const message = response.message || response.Message || errorCode;
2214
- response.message = message;
2215
- delete response.Message;
2216
- return Promise.reject(Object.assign(new Error(message), response));
2217
1567
  };
2218
1568
  const deserializeAws_json1_1ListAttributesCommand = async (output, context) => {
2219
1569
  if (output.statusCode >= 300) {
@@ -2240,35 +1590,19 @@ const deserializeAws_json1_1ListAttributesCommandError = async (output, context)
2240
1590
  switch (errorCode) {
2241
1591
  case "ClusterNotFoundException":
2242
1592
  case "com.amazonaws.ecs#ClusterNotFoundException":
2243
- response = {
2244
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
2245
- name: errorCode,
2246
- $metadata: deserializeMetadata(output),
2247
- };
2248
- break;
1593
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
2249
1594
  case "InvalidParameterException":
2250
1595
  case "com.amazonaws.ecs#InvalidParameterException":
2251
- response = {
2252
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2253
- name: errorCode,
2254
- $metadata: deserializeMetadata(output),
2255
- };
2256
- break;
1596
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2257
1597
  default:
2258
1598
  const parsedBody = parsedOutput.body;
2259
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2260
- response = {
2261
- ...parsedBody,
2262
- name: `${errorCode}`,
2263
- message: parsedBody.message || parsedBody.Message || errorCode,
1599
+ response = new ECSServiceException_1.ECSServiceException({
1600
+ name: parsedBody.code || parsedBody.Code || errorCode,
2264
1601
  $fault: "client",
2265
1602
  $metadata: deserializeMetadata(output),
2266
- };
1603
+ });
1604
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2267
1605
  }
2268
- const message = response.message || response.Message || errorCode;
2269
- response.message = message;
2270
- delete response.Message;
2271
- return Promise.reject(Object.assign(new Error(message), response));
2272
1606
  };
2273
1607
  const deserializeAws_json1_1ListClustersCommand = async (output, context) => {
2274
1608
  if (output.statusCode >= 300) {
@@ -2295,43 +1629,22 @@ const deserializeAws_json1_1ListClustersCommandError = async (output, context) =
2295
1629
  switch (errorCode) {
2296
1630
  case "ClientException":
2297
1631
  case "com.amazonaws.ecs#ClientException":
2298
- response = {
2299
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2300
- name: errorCode,
2301
- $metadata: deserializeMetadata(output),
2302
- };
2303
- break;
1632
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2304
1633
  case "InvalidParameterException":
2305
1634
  case "com.amazonaws.ecs#InvalidParameterException":
2306
- response = {
2307
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2308
- name: errorCode,
2309
- $metadata: deserializeMetadata(output),
2310
- };
2311
- break;
1635
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2312
1636
  case "ServerException":
2313
1637
  case "com.amazonaws.ecs#ServerException":
2314
- response = {
2315
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2316
- name: errorCode,
2317
- $metadata: deserializeMetadata(output),
2318
- };
2319
- break;
1638
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2320
1639
  default:
2321
1640
  const parsedBody = parsedOutput.body;
2322
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2323
- response = {
2324
- ...parsedBody,
2325
- name: `${errorCode}`,
2326
- message: parsedBody.message || parsedBody.Message || errorCode,
1641
+ response = new ECSServiceException_1.ECSServiceException({
1642
+ name: parsedBody.code || parsedBody.Code || errorCode,
2327
1643
  $fault: "client",
2328
1644
  $metadata: deserializeMetadata(output),
2329
- };
1645
+ });
1646
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2330
1647
  }
2331
- const message = response.message || response.Message || errorCode;
2332
- response.message = message;
2333
- delete response.Message;
2334
- return Promise.reject(Object.assign(new Error(message), response));
2335
1648
  };
2336
1649
  const deserializeAws_json1_1ListContainerInstancesCommand = async (output, context) => {
2337
1650
  if (output.statusCode >= 300) {
@@ -2358,51 +1671,25 @@ const deserializeAws_json1_1ListContainerInstancesCommandError = async (output,
2358
1671
  switch (errorCode) {
2359
1672
  case "ClientException":
2360
1673
  case "com.amazonaws.ecs#ClientException":
2361
- response = {
2362
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2363
- name: errorCode,
2364
- $metadata: deserializeMetadata(output),
2365
- };
2366
- break;
1674
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2367
1675
  case "ClusterNotFoundException":
2368
1676
  case "com.amazonaws.ecs#ClusterNotFoundException":
2369
- response = {
2370
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
2371
- name: errorCode,
2372
- $metadata: deserializeMetadata(output),
2373
- };
2374
- break;
1677
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
2375
1678
  case "InvalidParameterException":
2376
1679
  case "com.amazonaws.ecs#InvalidParameterException":
2377
- response = {
2378
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2379
- name: errorCode,
2380
- $metadata: deserializeMetadata(output),
2381
- };
2382
- break;
1680
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2383
1681
  case "ServerException":
2384
1682
  case "com.amazonaws.ecs#ServerException":
2385
- response = {
2386
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2387
- name: errorCode,
2388
- $metadata: deserializeMetadata(output),
2389
- };
2390
- break;
1683
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2391
1684
  default:
2392
1685
  const parsedBody = parsedOutput.body;
2393
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2394
- response = {
2395
- ...parsedBody,
2396
- name: `${errorCode}`,
2397
- message: parsedBody.message || parsedBody.Message || errorCode,
1686
+ response = new ECSServiceException_1.ECSServiceException({
1687
+ name: parsedBody.code || parsedBody.Code || errorCode,
2398
1688
  $fault: "client",
2399
1689
  $metadata: deserializeMetadata(output),
2400
- };
1690
+ });
1691
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2401
1692
  }
2402
- const message = response.message || response.Message || errorCode;
2403
- response.message = message;
2404
- delete response.Message;
2405
- return Promise.reject(Object.assign(new Error(message), response));
2406
1693
  };
2407
1694
  const deserializeAws_json1_1ListServicesCommand = async (output, context) => {
2408
1695
  if (output.statusCode >= 300) {
@@ -2429,51 +1716,25 @@ const deserializeAws_json1_1ListServicesCommandError = async (output, context) =
2429
1716
  switch (errorCode) {
2430
1717
  case "ClientException":
2431
1718
  case "com.amazonaws.ecs#ClientException":
2432
- response = {
2433
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2434
- name: errorCode,
2435
- $metadata: deserializeMetadata(output),
2436
- };
2437
- break;
1719
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2438
1720
  case "ClusterNotFoundException":
2439
1721
  case "com.amazonaws.ecs#ClusterNotFoundException":
2440
- response = {
2441
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
2442
- name: errorCode,
2443
- $metadata: deserializeMetadata(output),
2444
- };
2445
- break;
1722
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
2446
1723
  case "InvalidParameterException":
2447
1724
  case "com.amazonaws.ecs#InvalidParameterException":
2448
- response = {
2449
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2450
- name: errorCode,
2451
- $metadata: deserializeMetadata(output),
2452
- };
2453
- break;
1725
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2454
1726
  case "ServerException":
2455
1727
  case "com.amazonaws.ecs#ServerException":
2456
- response = {
2457
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2458
- name: errorCode,
2459
- $metadata: deserializeMetadata(output),
2460
- };
2461
- break;
1728
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2462
1729
  default:
2463
1730
  const parsedBody = parsedOutput.body;
2464
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2465
- response = {
2466
- ...parsedBody,
2467
- name: `${errorCode}`,
2468
- message: parsedBody.message || parsedBody.Message || errorCode,
1731
+ response = new ECSServiceException_1.ECSServiceException({
1732
+ name: parsedBody.code || parsedBody.Code || errorCode,
2469
1733
  $fault: "client",
2470
1734
  $metadata: deserializeMetadata(output),
2471
- };
1735
+ });
1736
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2472
1737
  }
2473
- const message = response.message || response.Message || errorCode;
2474
- response.message = message;
2475
- delete response.Message;
2476
- return Promise.reject(Object.assign(new Error(message), response));
2477
1738
  };
2478
1739
  const deserializeAws_json1_1ListTagsForResourceCommand = async (output, context) => {
2479
1740
  if (output.statusCode >= 300) {
@@ -2500,51 +1761,25 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
2500
1761
  switch (errorCode) {
2501
1762
  case "ClientException":
2502
1763
  case "com.amazonaws.ecs#ClientException":
2503
- response = {
2504
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2505
- name: errorCode,
2506
- $metadata: deserializeMetadata(output),
2507
- };
2508
- break;
1764
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2509
1765
  case "ClusterNotFoundException":
2510
1766
  case "com.amazonaws.ecs#ClusterNotFoundException":
2511
- response = {
2512
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
2513
- name: errorCode,
2514
- $metadata: deserializeMetadata(output),
2515
- };
2516
- break;
1767
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
2517
1768
  case "InvalidParameterException":
2518
1769
  case "com.amazonaws.ecs#InvalidParameterException":
2519
- response = {
2520
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2521
- name: errorCode,
2522
- $metadata: deserializeMetadata(output),
2523
- };
2524
- break;
1770
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2525
1771
  case "ServerException":
2526
1772
  case "com.amazonaws.ecs#ServerException":
2527
- response = {
2528
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2529
- name: errorCode,
2530
- $metadata: deserializeMetadata(output),
2531
- };
2532
- break;
1773
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2533
1774
  default:
2534
1775
  const parsedBody = parsedOutput.body;
2535
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2536
- response = {
2537
- ...parsedBody,
2538
- name: `${errorCode}`,
2539
- message: parsedBody.message || parsedBody.Message || errorCode,
1776
+ response = new ECSServiceException_1.ECSServiceException({
1777
+ name: parsedBody.code || parsedBody.Code || errorCode,
2540
1778
  $fault: "client",
2541
1779
  $metadata: deserializeMetadata(output),
2542
- };
1780
+ });
1781
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2543
1782
  }
2544
- const message = response.message || response.Message || errorCode;
2545
- response.message = message;
2546
- delete response.Message;
2547
- return Promise.reject(Object.assign(new Error(message), response));
2548
1783
  };
2549
1784
  const deserializeAws_json1_1ListTaskDefinitionFamiliesCommand = async (output, context) => {
2550
1785
  if (output.statusCode >= 300) {
@@ -2571,43 +1806,22 @@ const deserializeAws_json1_1ListTaskDefinitionFamiliesCommandError = async (outp
2571
1806
  switch (errorCode) {
2572
1807
  case "ClientException":
2573
1808
  case "com.amazonaws.ecs#ClientException":
2574
- response = {
2575
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2576
- name: errorCode,
2577
- $metadata: deserializeMetadata(output),
2578
- };
2579
- break;
1809
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2580
1810
  case "InvalidParameterException":
2581
1811
  case "com.amazonaws.ecs#InvalidParameterException":
2582
- response = {
2583
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2584
- name: errorCode,
2585
- $metadata: deserializeMetadata(output),
2586
- };
2587
- break;
1812
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2588
1813
  case "ServerException":
2589
1814
  case "com.amazonaws.ecs#ServerException":
2590
- response = {
2591
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2592
- name: errorCode,
2593
- $metadata: deserializeMetadata(output),
2594
- };
2595
- break;
1815
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2596
1816
  default:
2597
1817
  const parsedBody = parsedOutput.body;
2598
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2599
- response = {
2600
- ...parsedBody,
2601
- name: `${errorCode}`,
2602
- message: parsedBody.message || parsedBody.Message || errorCode,
1818
+ response = new ECSServiceException_1.ECSServiceException({
1819
+ name: parsedBody.code || parsedBody.Code || errorCode,
2603
1820
  $fault: "client",
2604
1821
  $metadata: deserializeMetadata(output),
2605
- };
1822
+ });
1823
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2606
1824
  }
2607
- const message = response.message || response.Message || errorCode;
2608
- response.message = message;
2609
- delete response.Message;
2610
- return Promise.reject(Object.assign(new Error(message), response));
2611
1825
  };
2612
1826
  const deserializeAws_json1_1ListTaskDefinitionsCommand = async (output, context) => {
2613
1827
  if (output.statusCode >= 300) {
@@ -2634,43 +1848,22 @@ const deserializeAws_json1_1ListTaskDefinitionsCommandError = async (output, con
2634
1848
  switch (errorCode) {
2635
1849
  case "ClientException":
2636
1850
  case "com.amazonaws.ecs#ClientException":
2637
- response = {
2638
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2639
- name: errorCode,
2640
- $metadata: deserializeMetadata(output),
2641
- };
2642
- break;
1851
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2643
1852
  case "InvalidParameterException":
2644
1853
  case "com.amazonaws.ecs#InvalidParameterException":
2645
- response = {
2646
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2647
- name: errorCode,
2648
- $metadata: deserializeMetadata(output),
2649
- };
2650
- break;
1854
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2651
1855
  case "ServerException":
2652
1856
  case "com.amazonaws.ecs#ServerException":
2653
- response = {
2654
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2655
- name: errorCode,
2656
- $metadata: deserializeMetadata(output),
2657
- };
2658
- break;
1857
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2659
1858
  default:
2660
1859
  const parsedBody = parsedOutput.body;
2661
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2662
- response = {
2663
- ...parsedBody,
2664
- name: `${errorCode}`,
2665
- message: parsedBody.message || parsedBody.Message || errorCode,
1860
+ response = new ECSServiceException_1.ECSServiceException({
1861
+ name: parsedBody.code || parsedBody.Code || errorCode,
2666
1862
  $fault: "client",
2667
1863
  $metadata: deserializeMetadata(output),
2668
- };
1864
+ });
1865
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2669
1866
  }
2670
- const message = response.message || response.Message || errorCode;
2671
- response.message = message;
2672
- delete response.Message;
2673
- return Promise.reject(Object.assign(new Error(message), response));
2674
1867
  };
2675
1868
  const deserializeAws_json1_1ListTasksCommand = async (output, context) => {
2676
1869
  if (output.statusCode >= 300) {
@@ -2697,59 +1890,28 @@ const deserializeAws_json1_1ListTasksCommandError = async (output, context) => {
2697
1890
  switch (errorCode) {
2698
1891
  case "ClientException":
2699
1892
  case "com.amazonaws.ecs#ClientException":
2700
- response = {
2701
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2702
- name: errorCode,
2703
- $metadata: deserializeMetadata(output),
2704
- };
2705
- break;
1893
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2706
1894
  case "ClusterNotFoundException":
2707
1895
  case "com.amazonaws.ecs#ClusterNotFoundException":
2708
- response = {
2709
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
2710
- name: errorCode,
2711
- $metadata: deserializeMetadata(output),
2712
- };
2713
- break;
1896
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
2714
1897
  case "InvalidParameterException":
2715
1898
  case "com.amazonaws.ecs#InvalidParameterException":
2716
- response = {
2717
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2718
- name: errorCode,
2719
- $metadata: deserializeMetadata(output),
2720
- };
2721
- break;
1899
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2722
1900
  case "ServerException":
2723
1901
  case "com.amazonaws.ecs#ServerException":
2724
- response = {
2725
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2726
- name: errorCode,
2727
- $metadata: deserializeMetadata(output),
2728
- };
2729
- break;
1902
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2730
1903
  case "ServiceNotFoundException":
2731
1904
  case "com.amazonaws.ecs#ServiceNotFoundException":
2732
- response = {
2733
- ...(await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context)),
2734
- name: errorCode,
2735
- $metadata: deserializeMetadata(output),
2736
- };
2737
- break;
1905
+ throw await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context);
2738
1906
  default:
2739
1907
  const parsedBody = parsedOutput.body;
2740
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2741
- response = {
2742
- ...parsedBody,
2743
- name: `${errorCode}`,
2744
- message: parsedBody.message || parsedBody.Message || errorCode,
1908
+ response = new ECSServiceException_1.ECSServiceException({
1909
+ name: parsedBody.code || parsedBody.Code || errorCode,
2745
1910
  $fault: "client",
2746
1911
  $metadata: deserializeMetadata(output),
2747
- };
1912
+ });
1913
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2748
1914
  }
2749
- const message = response.message || response.Message || errorCode;
2750
- response.message = message;
2751
- delete response.Message;
2752
- return Promise.reject(Object.assign(new Error(message), response));
2753
1915
  };
2754
1916
  const deserializeAws_json1_1PutAccountSettingCommand = async (output, context) => {
2755
1917
  if (output.statusCode >= 300) {
@@ -2776,43 +1938,22 @@ const deserializeAws_json1_1PutAccountSettingCommandError = async (output, conte
2776
1938
  switch (errorCode) {
2777
1939
  case "ClientException":
2778
1940
  case "com.amazonaws.ecs#ClientException":
2779
- response = {
2780
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2781
- name: errorCode,
2782
- $metadata: deserializeMetadata(output),
2783
- };
2784
- break;
1941
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2785
1942
  case "InvalidParameterException":
2786
1943
  case "com.amazonaws.ecs#InvalidParameterException":
2787
- response = {
2788
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2789
- name: errorCode,
2790
- $metadata: deserializeMetadata(output),
2791
- };
2792
- break;
1944
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2793
1945
  case "ServerException":
2794
1946
  case "com.amazonaws.ecs#ServerException":
2795
- response = {
2796
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2797
- name: errorCode,
2798
- $metadata: deserializeMetadata(output),
2799
- };
2800
- break;
1947
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2801
1948
  default:
2802
1949
  const parsedBody = parsedOutput.body;
2803
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2804
- response = {
2805
- ...parsedBody,
2806
- name: `${errorCode}`,
2807
- message: parsedBody.message || parsedBody.Message || errorCode,
1950
+ response = new ECSServiceException_1.ECSServiceException({
1951
+ name: parsedBody.code || parsedBody.Code || errorCode,
2808
1952
  $fault: "client",
2809
1953
  $metadata: deserializeMetadata(output),
2810
- };
1954
+ });
1955
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2811
1956
  }
2812
- const message = response.message || response.Message || errorCode;
2813
- response.message = message;
2814
- delete response.Message;
2815
- return Promise.reject(Object.assign(new Error(message), response));
2816
1957
  };
2817
1958
  const deserializeAws_json1_1PutAccountSettingDefaultCommand = async (output, context) => {
2818
1959
  if (output.statusCode >= 300) {
@@ -2839,43 +1980,22 @@ const deserializeAws_json1_1PutAccountSettingDefaultCommandError = async (output
2839
1980
  switch (errorCode) {
2840
1981
  case "ClientException":
2841
1982
  case "com.amazonaws.ecs#ClientException":
2842
- response = {
2843
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2844
- name: errorCode,
2845
- $metadata: deserializeMetadata(output),
2846
- };
2847
- break;
1983
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2848
1984
  case "InvalidParameterException":
2849
1985
  case "com.amazonaws.ecs#InvalidParameterException":
2850
- response = {
2851
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2852
- name: errorCode,
2853
- $metadata: deserializeMetadata(output),
2854
- };
2855
- break;
1986
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2856
1987
  case "ServerException":
2857
1988
  case "com.amazonaws.ecs#ServerException":
2858
- response = {
2859
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
2860
- name: errorCode,
2861
- $metadata: deserializeMetadata(output),
2862
- };
2863
- break;
1989
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
2864
1990
  default:
2865
1991
  const parsedBody = parsedOutput.body;
2866
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2867
- response = {
2868
- ...parsedBody,
2869
- name: `${errorCode}`,
2870
- message: parsedBody.message || parsedBody.Message || errorCode,
1992
+ response = new ECSServiceException_1.ECSServiceException({
1993
+ name: parsedBody.code || parsedBody.Code || errorCode,
2871
1994
  $fault: "client",
2872
1995
  $metadata: deserializeMetadata(output),
2873
- };
1996
+ });
1997
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2874
1998
  }
2875
- const message = response.message || response.Message || errorCode;
2876
- response.message = message;
2877
- delete response.Message;
2878
- return Promise.reject(Object.assign(new Error(message), response));
2879
1999
  };
2880
2000
  const deserializeAws_json1_1PutAttributesCommand = async (output, context) => {
2881
2001
  if (output.statusCode >= 300) {
@@ -2902,51 +2022,25 @@ const deserializeAws_json1_1PutAttributesCommandError = async (output, context)
2902
2022
  switch (errorCode) {
2903
2023
  case "AttributeLimitExceededException":
2904
2024
  case "com.amazonaws.ecs#AttributeLimitExceededException":
2905
- response = {
2906
- ...(await deserializeAws_json1_1AttributeLimitExceededExceptionResponse(parsedOutput, context)),
2907
- name: errorCode,
2908
- $metadata: deserializeMetadata(output),
2909
- };
2910
- break;
2025
+ throw await deserializeAws_json1_1AttributeLimitExceededExceptionResponse(parsedOutput, context);
2911
2026
  case "ClusterNotFoundException":
2912
2027
  case "com.amazonaws.ecs#ClusterNotFoundException":
2913
- response = {
2914
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
2915
- name: errorCode,
2916
- $metadata: deserializeMetadata(output),
2917
- };
2918
- break;
2028
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
2919
2029
  case "InvalidParameterException":
2920
2030
  case "com.amazonaws.ecs#InvalidParameterException":
2921
- response = {
2922
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2923
- name: errorCode,
2924
- $metadata: deserializeMetadata(output),
2925
- };
2926
- break;
2031
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2927
2032
  case "TargetNotFoundException":
2928
2033
  case "com.amazonaws.ecs#TargetNotFoundException":
2929
- response = {
2930
- ...(await deserializeAws_json1_1TargetNotFoundExceptionResponse(parsedOutput, context)),
2931
- name: errorCode,
2932
- $metadata: deserializeMetadata(output),
2933
- };
2934
- break;
2034
+ throw await deserializeAws_json1_1TargetNotFoundExceptionResponse(parsedOutput, context);
2935
2035
  default:
2936
2036
  const parsedBody = parsedOutput.body;
2937
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2938
- response = {
2939
- ...parsedBody,
2940
- name: `${errorCode}`,
2941
- message: parsedBody.message || parsedBody.Message || errorCode,
2037
+ response = new ECSServiceException_1.ECSServiceException({
2038
+ name: parsedBody.code || parsedBody.Code || errorCode,
2942
2039
  $fault: "client",
2943
2040
  $metadata: deserializeMetadata(output),
2944
- };
2041
+ });
2042
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2945
2043
  }
2946
- const message = response.message || response.Message || errorCode;
2947
- response.message = message;
2948
- delete response.Message;
2949
- return Promise.reject(Object.assign(new Error(message), response));
2950
2044
  };
2951
2045
  const deserializeAws_json1_1PutClusterCapacityProvidersCommand = async (output, context) => {
2952
2046
  if (output.statusCode >= 300) {
@@ -2973,67 +2067,31 @@ const deserializeAws_json1_1PutClusterCapacityProvidersCommandError = async (out
2973
2067
  switch (errorCode) {
2974
2068
  case "ClientException":
2975
2069
  case "com.amazonaws.ecs#ClientException":
2976
- response = {
2977
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
2978
- name: errorCode,
2979
- $metadata: deserializeMetadata(output),
2980
- };
2981
- break;
2070
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
2982
2071
  case "ClusterNotFoundException":
2983
2072
  case "com.amazonaws.ecs#ClusterNotFoundException":
2984
- response = {
2985
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
2986
- name: errorCode,
2987
- $metadata: deserializeMetadata(output),
2988
- };
2989
- break;
2073
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
2990
2074
  case "InvalidParameterException":
2991
2075
  case "com.amazonaws.ecs#InvalidParameterException":
2992
- response = {
2993
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
2994
- name: errorCode,
2995
- $metadata: deserializeMetadata(output),
2996
- };
2997
- break;
2076
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
2998
2077
  case "ResourceInUseException":
2999
2078
  case "com.amazonaws.ecs#ResourceInUseException":
3000
- response = {
3001
- ...(await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)),
3002
- name: errorCode,
3003
- $metadata: deserializeMetadata(output),
3004
- };
3005
- break;
2079
+ throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
3006
2080
  case "ServerException":
3007
2081
  case "com.amazonaws.ecs#ServerException":
3008
- response = {
3009
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3010
- name: errorCode,
3011
- $metadata: deserializeMetadata(output),
3012
- };
3013
- break;
2082
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3014
2083
  case "UpdateInProgressException":
3015
2084
  case "com.amazonaws.ecs#UpdateInProgressException":
3016
- response = {
3017
- ...(await deserializeAws_json1_1UpdateInProgressExceptionResponse(parsedOutput, context)),
3018
- name: errorCode,
3019
- $metadata: deserializeMetadata(output),
3020
- };
3021
- break;
2085
+ throw await deserializeAws_json1_1UpdateInProgressExceptionResponse(parsedOutput, context);
3022
2086
  default:
3023
2087
  const parsedBody = parsedOutput.body;
3024
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3025
- response = {
3026
- ...parsedBody,
3027
- name: `${errorCode}`,
3028
- message: parsedBody.message || parsedBody.Message || errorCode,
2088
+ response = new ECSServiceException_1.ECSServiceException({
2089
+ name: parsedBody.code || parsedBody.Code || errorCode,
3029
2090
  $fault: "client",
3030
2091
  $metadata: deserializeMetadata(output),
3031
- };
2092
+ });
2093
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3032
2094
  }
3033
- const message = response.message || response.Message || errorCode;
3034
- response.message = message;
3035
- delete response.Message;
3036
- return Promise.reject(Object.assign(new Error(message), response));
3037
2095
  };
3038
2096
  const deserializeAws_json1_1RegisterContainerInstanceCommand = async (output, context) => {
3039
2097
  if (output.statusCode >= 300) {
@@ -3060,43 +2118,22 @@ const deserializeAws_json1_1RegisterContainerInstanceCommandError = async (outpu
3060
2118
  switch (errorCode) {
3061
2119
  case "ClientException":
3062
2120
  case "com.amazonaws.ecs#ClientException":
3063
- response = {
3064
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3065
- name: errorCode,
3066
- $metadata: deserializeMetadata(output),
3067
- };
3068
- break;
2121
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3069
2122
  case "InvalidParameterException":
3070
2123
  case "com.amazonaws.ecs#InvalidParameterException":
3071
- response = {
3072
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3073
- name: errorCode,
3074
- $metadata: deserializeMetadata(output),
3075
- };
3076
- break;
2124
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3077
2125
  case "ServerException":
3078
2126
  case "com.amazonaws.ecs#ServerException":
3079
- response = {
3080
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3081
- name: errorCode,
3082
- $metadata: deserializeMetadata(output),
3083
- };
3084
- break;
2127
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3085
2128
  default:
3086
2129
  const parsedBody = parsedOutput.body;
3087
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3088
- response = {
3089
- ...parsedBody,
3090
- name: `${errorCode}`,
3091
- message: parsedBody.message || parsedBody.Message || errorCode,
2130
+ response = new ECSServiceException_1.ECSServiceException({
2131
+ name: parsedBody.code || parsedBody.Code || errorCode,
3092
2132
  $fault: "client",
3093
2133
  $metadata: deserializeMetadata(output),
3094
- };
2134
+ });
2135
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3095
2136
  }
3096
- const message = response.message || response.Message || errorCode;
3097
- response.message = message;
3098
- delete response.Message;
3099
- return Promise.reject(Object.assign(new Error(message), response));
3100
2137
  };
3101
2138
  const deserializeAws_json1_1RegisterTaskDefinitionCommand = async (output, context) => {
3102
2139
  if (output.statusCode >= 300) {
@@ -3123,43 +2160,22 @@ const deserializeAws_json1_1RegisterTaskDefinitionCommandError = async (output,
3123
2160
  switch (errorCode) {
3124
2161
  case "ClientException":
3125
2162
  case "com.amazonaws.ecs#ClientException":
3126
- response = {
3127
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3128
- name: errorCode,
3129
- $metadata: deserializeMetadata(output),
3130
- };
3131
- break;
2163
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3132
2164
  case "InvalidParameterException":
3133
2165
  case "com.amazonaws.ecs#InvalidParameterException":
3134
- response = {
3135
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3136
- name: errorCode,
3137
- $metadata: deserializeMetadata(output),
3138
- };
3139
- break;
2166
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3140
2167
  case "ServerException":
3141
2168
  case "com.amazonaws.ecs#ServerException":
3142
- response = {
3143
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3144
- name: errorCode,
3145
- $metadata: deserializeMetadata(output),
3146
- };
3147
- break;
2169
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3148
2170
  default:
3149
2171
  const parsedBody = parsedOutput.body;
3150
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3151
- response = {
3152
- ...parsedBody,
3153
- name: `${errorCode}`,
3154
- message: parsedBody.message || parsedBody.Message || errorCode,
2172
+ response = new ECSServiceException_1.ECSServiceException({
2173
+ name: parsedBody.code || parsedBody.Code || errorCode,
3155
2174
  $fault: "client",
3156
2175
  $metadata: deserializeMetadata(output),
3157
- };
2176
+ });
2177
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3158
2178
  }
3159
- const message = response.message || response.Message || errorCode;
3160
- response.message = message;
3161
- delete response.Message;
3162
- return Promise.reject(Object.assign(new Error(message), response));
3163
2179
  };
3164
2180
  const deserializeAws_json1_1RunTaskCommand = async (output, context) => {
3165
2181
  if (output.statusCode >= 300) {
@@ -3186,91 +2202,40 @@ const deserializeAws_json1_1RunTaskCommandError = async (output, context) => {
3186
2202
  switch (errorCode) {
3187
2203
  case "AccessDeniedException":
3188
2204
  case "com.amazonaws.ecs#AccessDeniedException":
3189
- response = {
3190
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
3191
- name: errorCode,
3192
- $metadata: deserializeMetadata(output),
3193
- };
3194
- break;
2205
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
3195
2206
  case "BlockedException":
3196
2207
  case "com.amazonaws.ecs#BlockedException":
3197
- response = {
3198
- ...(await deserializeAws_json1_1BlockedExceptionResponse(parsedOutput, context)),
3199
- name: errorCode,
3200
- $metadata: deserializeMetadata(output),
3201
- };
3202
- break;
2208
+ throw await deserializeAws_json1_1BlockedExceptionResponse(parsedOutput, context);
3203
2209
  case "ClientException":
3204
2210
  case "com.amazonaws.ecs#ClientException":
3205
- response = {
3206
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3207
- name: errorCode,
3208
- $metadata: deserializeMetadata(output),
3209
- };
3210
- break;
2211
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3211
2212
  case "ClusterNotFoundException":
3212
2213
  case "com.amazonaws.ecs#ClusterNotFoundException":
3213
- response = {
3214
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
3215
- name: errorCode,
3216
- $metadata: deserializeMetadata(output),
3217
- };
3218
- break;
2214
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
3219
2215
  case "InvalidParameterException":
3220
2216
  case "com.amazonaws.ecs#InvalidParameterException":
3221
- response = {
3222
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3223
- name: errorCode,
3224
- $metadata: deserializeMetadata(output),
3225
- };
3226
- break;
2217
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3227
2218
  case "PlatformTaskDefinitionIncompatibilityException":
3228
2219
  case "com.amazonaws.ecs#PlatformTaskDefinitionIncompatibilityException":
3229
- response = {
3230
- ...(await deserializeAws_json1_1PlatformTaskDefinitionIncompatibilityExceptionResponse(parsedOutput, context)),
3231
- name: errorCode,
3232
- $metadata: deserializeMetadata(output),
3233
- };
3234
- break;
2220
+ throw await deserializeAws_json1_1PlatformTaskDefinitionIncompatibilityExceptionResponse(parsedOutput, context);
3235
2221
  case "PlatformUnknownException":
3236
2222
  case "com.amazonaws.ecs#PlatformUnknownException":
3237
- response = {
3238
- ...(await deserializeAws_json1_1PlatformUnknownExceptionResponse(parsedOutput, context)),
3239
- name: errorCode,
3240
- $metadata: deserializeMetadata(output),
3241
- };
3242
- break;
2223
+ throw await deserializeAws_json1_1PlatformUnknownExceptionResponse(parsedOutput, context);
3243
2224
  case "ServerException":
3244
2225
  case "com.amazonaws.ecs#ServerException":
3245
- response = {
3246
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3247
- name: errorCode,
3248
- $metadata: deserializeMetadata(output),
3249
- };
3250
- break;
2226
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3251
2227
  case "UnsupportedFeatureException":
3252
2228
  case "com.amazonaws.ecs#UnsupportedFeatureException":
3253
- response = {
3254
- ...(await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context)),
3255
- name: errorCode,
3256
- $metadata: deserializeMetadata(output),
3257
- };
3258
- break;
2229
+ throw await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context);
3259
2230
  default:
3260
2231
  const parsedBody = parsedOutput.body;
3261
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3262
- response = {
3263
- ...parsedBody,
3264
- name: `${errorCode}`,
3265
- message: parsedBody.message || parsedBody.Message || errorCode,
2232
+ response = new ECSServiceException_1.ECSServiceException({
2233
+ name: parsedBody.code || parsedBody.Code || errorCode,
3266
2234
  $fault: "client",
3267
2235
  $metadata: deserializeMetadata(output),
3268
- };
2236
+ });
2237
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3269
2238
  }
3270
- const message = response.message || response.Message || errorCode;
3271
- response.message = message;
3272
- delete response.Message;
3273
- return Promise.reject(Object.assign(new Error(message), response));
3274
2239
  };
3275
2240
  const deserializeAws_json1_1StartTaskCommand = async (output, context) => {
3276
2241
  if (output.statusCode >= 300) {
@@ -3297,51 +2262,25 @@ const deserializeAws_json1_1StartTaskCommandError = async (output, context) => {
3297
2262
  switch (errorCode) {
3298
2263
  case "ClientException":
3299
2264
  case "com.amazonaws.ecs#ClientException":
3300
- response = {
3301
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3302
- name: errorCode,
3303
- $metadata: deserializeMetadata(output),
3304
- };
3305
- break;
2265
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3306
2266
  case "ClusterNotFoundException":
3307
2267
  case "com.amazonaws.ecs#ClusterNotFoundException":
3308
- response = {
3309
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
3310
- name: errorCode,
3311
- $metadata: deserializeMetadata(output),
3312
- };
3313
- break;
2268
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
3314
2269
  case "InvalidParameterException":
3315
2270
  case "com.amazonaws.ecs#InvalidParameterException":
3316
- response = {
3317
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3318
- name: errorCode,
3319
- $metadata: deserializeMetadata(output),
3320
- };
3321
- break;
2271
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3322
2272
  case "ServerException":
3323
2273
  case "com.amazonaws.ecs#ServerException":
3324
- response = {
3325
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3326
- name: errorCode,
3327
- $metadata: deserializeMetadata(output),
3328
- };
3329
- break;
2274
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3330
2275
  default:
3331
2276
  const parsedBody = parsedOutput.body;
3332
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3333
- response = {
3334
- ...parsedBody,
3335
- name: `${errorCode}`,
3336
- message: parsedBody.message || parsedBody.Message || errorCode,
2277
+ response = new ECSServiceException_1.ECSServiceException({
2278
+ name: parsedBody.code || parsedBody.Code || errorCode,
3337
2279
  $fault: "client",
3338
2280
  $metadata: deserializeMetadata(output),
3339
- };
2281
+ });
2282
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3340
2283
  }
3341
- const message = response.message || response.Message || errorCode;
3342
- response.message = message;
3343
- delete response.Message;
3344
- return Promise.reject(Object.assign(new Error(message), response));
3345
2284
  };
3346
2285
  const deserializeAws_json1_1StopTaskCommand = async (output, context) => {
3347
2286
  if (output.statusCode >= 300) {
@@ -3368,51 +2307,25 @@ const deserializeAws_json1_1StopTaskCommandError = async (output, context) => {
3368
2307
  switch (errorCode) {
3369
2308
  case "ClientException":
3370
2309
  case "com.amazonaws.ecs#ClientException":
3371
- response = {
3372
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3373
- name: errorCode,
3374
- $metadata: deserializeMetadata(output),
3375
- };
3376
- break;
2310
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3377
2311
  case "ClusterNotFoundException":
3378
2312
  case "com.amazonaws.ecs#ClusterNotFoundException":
3379
- response = {
3380
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
3381
- name: errorCode,
3382
- $metadata: deserializeMetadata(output),
3383
- };
3384
- break;
2313
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
3385
2314
  case "InvalidParameterException":
3386
2315
  case "com.amazonaws.ecs#InvalidParameterException":
3387
- response = {
3388
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3389
- name: errorCode,
3390
- $metadata: deserializeMetadata(output),
3391
- };
3392
- break;
2316
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3393
2317
  case "ServerException":
3394
2318
  case "com.amazonaws.ecs#ServerException":
3395
- response = {
3396
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3397
- name: errorCode,
3398
- $metadata: deserializeMetadata(output),
3399
- };
3400
- break;
2319
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3401
2320
  default:
3402
2321
  const parsedBody = parsedOutput.body;
3403
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3404
- response = {
3405
- ...parsedBody,
3406
- name: `${errorCode}`,
3407
- message: parsedBody.message || parsedBody.Message || errorCode,
2322
+ response = new ECSServiceException_1.ECSServiceException({
2323
+ name: parsedBody.code || parsedBody.Code || errorCode,
3408
2324
  $fault: "client",
3409
2325
  $metadata: deserializeMetadata(output),
3410
- };
2326
+ });
2327
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3411
2328
  }
3412
- const message = response.message || response.Message || errorCode;
3413
- response.message = message;
3414
- delete response.Message;
3415
- return Promise.reject(Object.assign(new Error(message), response));
3416
2329
  };
3417
2330
  const deserializeAws_json1_1SubmitAttachmentStateChangesCommand = async (output, context) => {
3418
2331
  if (output.statusCode >= 300) {
@@ -3439,51 +2352,25 @@ const deserializeAws_json1_1SubmitAttachmentStateChangesCommandError = async (ou
3439
2352
  switch (errorCode) {
3440
2353
  case "AccessDeniedException":
3441
2354
  case "com.amazonaws.ecs#AccessDeniedException":
3442
- response = {
3443
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
3444
- name: errorCode,
3445
- $metadata: deserializeMetadata(output),
3446
- };
3447
- break;
2355
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
3448
2356
  case "ClientException":
3449
2357
  case "com.amazonaws.ecs#ClientException":
3450
- response = {
3451
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3452
- name: errorCode,
3453
- $metadata: deserializeMetadata(output),
3454
- };
3455
- break;
2358
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3456
2359
  case "InvalidParameterException":
3457
2360
  case "com.amazonaws.ecs#InvalidParameterException":
3458
- response = {
3459
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3460
- name: errorCode,
3461
- $metadata: deserializeMetadata(output),
3462
- };
3463
- break;
2361
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3464
2362
  case "ServerException":
3465
2363
  case "com.amazonaws.ecs#ServerException":
3466
- response = {
3467
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3468
- name: errorCode,
3469
- $metadata: deserializeMetadata(output),
3470
- };
3471
- break;
2364
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3472
2365
  default:
3473
2366
  const parsedBody = parsedOutput.body;
3474
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3475
- response = {
3476
- ...parsedBody,
3477
- name: `${errorCode}`,
3478
- message: parsedBody.message || parsedBody.Message || errorCode,
2367
+ response = new ECSServiceException_1.ECSServiceException({
2368
+ name: parsedBody.code || parsedBody.Code || errorCode,
3479
2369
  $fault: "client",
3480
2370
  $metadata: deserializeMetadata(output),
3481
- };
2371
+ });
2372
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3482
2373
  }
3483
- const message = response.message || response.Message || errorCode;
3484
- response.message = message;
3485
- delete response.Message;
3486
- return Promise.reject(Object.assign(new Error(message), response));
3487
2374
  };
3488
2375
  const deserializeAws_json1_1SubmitContainerStateChangeCommand = async (output, context) => {
3489
2376
  if (output.statusCode >= 300) {
@@ -3510,43 +2397,22 @@ const deserializeAws_json1_1SubmitContainerStateChangeCommandError = async (outp
3510
2397
  switch (errorCode) {
3511
2398
  case "AccessDeniedException":
3512
2399
  case "com.amazonaws.ecs#AccessDeniedException":
3513
- response = {
3514
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
3515
- name: errorCode,
3516
- $metadata: deserializeMetadata(output),
3517
- };
3518
- break;
2400
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
3519
2401
  case "ClientException":
3520
2402
  case "com.amazonaws.ecs#ClientException":
3521
- response = {
3522
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3523
- name: errorCode,
3524
- $metadata: deserializeMetadata(output),
3525
- };
3526
- break;
2403
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3527
2404
  case "ServerException":
3528
2405
  case "com.amazonaws.ecs#ServerException":
3529
- response = {
3530
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3531
- name: errorCode,
3532
- $metadata: deserializeMetadata(output),
3533
- };
3534
- break;
2406
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3535
2407
  default:
3536
2408
  const parsedBody = parsedOutput.body;
3537
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3538
- response = {
3539
- ...parsedBody,
3540
- name: `${errorCode}`,
3541
- message: parsedBody.message || parsedBody.Message || errorCode,
2409
+ response = new ECSServiceException_1.ECSServiceException({
2410
+ name: parsedBody.code || parsedBody.Code || errorCode,
3542
2411
  $fault: "client",
3543
2412
  $metadata: deserializeMetadata(output),
3544
- };
2413
+ });
2414
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3545
2415
  }
3546
- const message = response.message || response.Message || errorCode;
3547
- response.message = message;
3548
- delete response.Message;
3549
- return Promise.reject(Object.assign(new Error(message), response));
3550
2416
  };
3551
2417
  const deserializeAws_json1_1SubmitTaskStateChangeCommand = async (output, context) => {
3552
2418
  if (output.statusCode >= 300) {
@@ -3573,51 +2439,25 @@ const deserializeAws_json1_1SubmitTaskStateChangeCommandError = async (output, c
3573
2439
  switch (errorCode) {
3574
2440
  case "AccessDeniedException":
3575
2441
  case "com.amazonaws.ecs#AccessDeniedException":
3576
- response = {
3577
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
3578
- name: errorCode,
3579
- $metadata: deserializeMetadata(output),
3580
- };
3581
- break;
2442
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
3582
2443
  case "ClientException":
3583
2444
  case "com.amazonaws.ecs#ClientException":
3584
- response = {
3585
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3586
- name: errorCode,
3587
- $metadata: deserializeMetadata(output),
3588
- };
3589
- break;
2445
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3590
2446
  case "InvalidParameterException":
3591
2447
  case "com.amazonaws.ecs#InvalidParameterException":
3592
- response = {
3593
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3594
- name: errorCode,
3595
- $metadata: deserializeMetadata(output),
3596
- };
3597
- break;
2448
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3598
2449
  case "ServerException":
3599
2450
  case "com.amazonaws.ecs#ServerException":
3600
- response = {
3601
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3602
- name: errorCode,
3603
- $metadata: deserializeMetadata(output),
3604
- };
3605
- break;
2451
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3606
2452
  default:
3607
2453
  const parsedBody = parsedOutput.body;
3608
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3609
- response = {
3610
- ...parsedBody,
3611
- name: `${errorCode}`,
3612
- message: parsedBody.message || parsedBody.Message || errorCode,
2454
+ response = new ECSServiceException_1.ECSServiceException({
2455
+ name: parsedBody.code || parsedBody.Code || errorCode,
3613
2456
  $fault: "client",
3614
2457
  $metadata: deserializeMetadata(output),
3615
- };
2458
+ });
2459
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3616
2460
  }
3617
- const message = response.message || response.Message || errorCode;
3618
- response.message = message;
3619
- delete response.Message;
3620
- return Promise.reject(Object.assign(new Error(message), response));
3621
2461
  };
3622
2462
  const deserializeAws_json1_1TagResourceCommand = async (output, context) => {
3623
2463
  if (output.statusCode >= 300) {
@@ -3644,59 +2484,28 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
3644
2484
  switch (errorCode) {
3645
2485
  case "ClientException":
3646
2486
  case "com.amazonaws.ecs#ClientException":
3647
- response = {
3648
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3649
- name: errorCode,
3650
- $metadata: deserializeMetadata(output),
3651
- };
3652
- break;
2487
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3653
2488
  case "ClusterNotFoundException":
3654
2489
  case "com.amazonaws.ecs#ClusterNotFoundException":
3655
- response = {
3656
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
3657
- name: errorCode,
3658
- $metadata: deserializeMetadata(output),
3659
- };
3660
- break;
2490
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
3661
2491
  case "InvalidParameterException":
3662
2492
  case "com.amazonaws.ecs#InvalidParameterException":
3663
- response = {
3664
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3665
- name: errorCode,
3666
- $metadata: deserializeMetadata(output),
3667
- };
3668
- break;
2493
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3669
2494
  case "ResourceNotFoundException":
3670
2495
  case "com.amazonaws.ecs#ResourceNotFoundException":
3671
- response = {
3672
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
3673
- name: errorCode,
3674
- $metadata: deserializeMetadata(output),
3675
- };
3676
- break;
2496
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
3677
2497
  case "ServerException":
3678
2498
  case "com.amazonaws.ecs#ServerException":
3679
- response = {
3680
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3681
- name: errorCode,
3682
- $metadata: deserializeMetadata(output),
3683
- };
3684
- break;
2499
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3685
2500
  default:
3686
2501
  const parsedBody = parsedOutput.body;
3687
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3688
- response = {
3689
- ...parsedBody,
3690
- name: `${errorCode}`,
3691
- message: parsedBody.message || parsedBody.Message || errorCode,
2502
+ response = new ECSServiceException_1.ECSServiceException({
2503
+ name: parsedBody.code || parsedBody.Code || errorCode,
3692
2504
  $fault: "client",
3693
2505
  $metadata: deserializeMetadata(output),
3694
- };
2506
+ });
2507
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3695
2508
  }
3696
- const message = response.message || response.Message || errorCode;
3697
- response.message = message;
3698
- delete response.Message;
3699
- return Promise.reject(Object.assign(new Error(message), response));
3700
2509
  };
3701
2510
  const deserializeAws_json1_1UntagResourceCommand = async (output, context) => {
3702
2511
  if (output.statusCode >= 300) {
@@ -3723,59 +2532,28 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
3723
2532
  switch (errorCode) {
3724
2533
  case "ClientException":
3725
2534
  case "com.amazonaws.ecs#ClientException":
3726
- response = {
3727
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3728
- name: errorCode,
3729
- $metadata: deserializeMetadata(output),
3730
- };
3731
- break;
2535
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3732
2536
  case "ClusterNotFoundException":
3733
2537
  case "com.amazonaws.ecs#ClusterNotFoundException":
3734
- response = {
3735
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
3736
- name: errorCode,
3737
- $metadata: deserializeMetadata(output),
3738
- };
3739
- break;
2538
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
3740
2539
  case "InvalidParameterException":
3741
2540
  case "com.amazonaws.ecs#InvalidParameterException":
3742
- response = {
3743
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3744
- name: errorCode,
3745
- $metadata: deserializeMetadata(output),
3746
- };
3747
- break;
2541
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3748
2542
  case "ResourceNotFoundException":
3749
2543
  case "com.amazonaws.ecs#ResourceNotFoundException":
3750
- response = {
3751
- ...(await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context)),
3752
- name: errorCode,
3753
- $metadata: deserializeMetadata(output),
3754
- };
3755
- break;
2544
+ throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
3756
2545
  case "ServerException":
3757
2546
  case "com.amazonaws.ecs#ServerException":
3758
- response = {
3759
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3760
- name: errorCode,
3761
- $metadata: deserializeMetadata(output),
3762
- };
3763
- break;
2547
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3764
2548
  default:
3765
2549
  const parsedBody = parsedOutput.body;
3766
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3767
- response = {
3768
- ...parsedBody,
3769
- name: `${errorCode}`,
3770
- message: parsedBody.message || parsedBody.Message || errorCode,
2550
+ response = new ECSServiceException_1.ECSServiceException({
2551
+ name: parsedBody.code || parsedBody.Code || errorCode,
3771
2552
  $fault: "client",
3772
2553
  $metadata: deserializeMetadata(output),
3773
- };
2554
+ });
2555
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3774
2556
  }
3775
- const message = response.message || response.Message || errorCode;
3776
- response.message = message;
3777
- delete response.Message;
3778
- return Promise.reject(Object.assign(new Error(message), response));
3779
2557
  };
3780
2558
  const deserializeAws_json1_1UpdateCapacityProviderCommand = async (output, context) => {
3781
2559
  if (output.statusCode >= 300) {
@@ -3802,43 +2580,22 @@ const deserializeAws_json1_1UpdateCapacityProviderCommandError = async (output,
3802
2580
  switch (errorCode) {
3803
2581
  case "ClientException":
3804
2582
  case "com.amazonaws.ecs#ClientException":
3805
- response = {
3806
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3807
- name: errorCode,
3808
- $metadata: deserializeMetadata(output),
3809
- };
3810
- break;
2583
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3811
2584
  case "InvalidParameterException":
3812
2585
  case "com.amazonaws.ecs#InvalidParameterException":
3813
- response = {
3814
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3815
- name: errorCode,
3816
- $metadata: deserializeMetadata(output),
3817
- };
3818
- break;
2586
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3819
2587
  case "ServerException":
3820
2588
  case "com.amazonaws.ecs#ServerException":
3821
- response = {
3822
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3823
- name: errorCode,
3824
- $metadata: deserializeMetadata(output),
3825
- };
3826
- break;
2589
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3827
2590
  default:
3828
2591
  const parsedBody = parsedOutput.body;
3829
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3830
- response = {
3831
- ...parsedBody,
3832
- name: `${errorCode}`,
3833
- message: parsedBody.message || parsedBody.Message || errorCode,
2592
+ response = new ECSServiceException_1.ECSServiceException({
2593
+ name: parsedBody.code || parsedBody.Code || errorCode,
3834
2594
  $fault: "client",
3835
2595
  $metadata: deserializeMetadata(output),
3836
- };
2596
+ });
2597
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3837
2598
  }
3838
- const message = response.message || response.Message || errorCode;
3839
- response.message = message;
3840
- delete response.Message;
3841
- return Promise.reject(Object.assign(new Error(message), response));
3842
2599
  };
3843
2600
  const deserializeAws_json1_1UpdateClusterCommand = async (output, context) => {
3844
2601
  if (output.statusCode >= 300) {
@@ -3865,51 +2622,25 @@ const deserializeAws_json1_1UpdateClusterCommandError = async (output, context)
3865
2622
  switch (errorCode) {
3866
2623
  case "ClientException":
3867
2624
  case "com.amazonaws.ecs#ClientException":
3868
- response = {
3869
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3870
- name: errorCode,
3871
- $metadata: deserializeMetadata(output),
3872
- };
3873
- break;
2625
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3874
2626
  case "ClusterNotFoundException":
3875
2627
  case "com.amazonaws.ecs#ClusterNotFoundException":
3876
- response = {
3877
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
3878
- name: errorCode,
3879
- $metadata: deserializeMetadata(output),
3880
- };
3881
- break;
2628
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
3882
2629
  case "InvalidParameterException":
3883
2630
  case "com.amazonaws.ecs#InvalidParameterException":
3884
- response = {
3885
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3886
- name: errorCode,
3887
- $metadata: deserializeMetadata(output),
3888
- };
3889
- break;
2631
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3890
2632
  case "ServerException":
3891
2633
  case "com.amazonaws.ecs#ServerException":
3892
- response = {
3893
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3894
- name: errorCode,
3895
- $metadata: deserializeMetadata(output),
3896
- };
3897
- break;
2634
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3898
2635
  default:
3899
2636
  const parsedBody = parsedOutput.body;
3900
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3901
- response = {
3902
- ...parsedBody,
3903
- name: `${errorCode}`,
3904
- message: parsedBody.message || parsedBody.Message || errorCode,
2637
+ response = new ECSServiceException_1.ECSServiceException({
2638
+ name: parsedBody.code || parsedBody.Code || errorCode,
3905
2639
  $fault: "client",
3906
2640
  $metadata: deserializeMetadata(output),
3907
- };
2641
+ });
2642
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3908
2643
  }
3909
- const message = response.message || response.Message || errorCode;
3910
- response.message = message;
3911
- delete response.Message;
3912
- return Promise.reject(Object.assign(new Error(message), response));
3913
2644
  };
3914
2645
  const deserializeAws_json1_1UpdateClusterSettingsCommand = async (output, context) => {
3915
2646
  if (output.statusCode >= 300) {
@@ -3936,51 +2667,25 @@ const deserializeAws_json1_1UpdateClusterSettingsCommandError = async (output, c
3936
2667
  switch (errorCode) {
3937
2668
  case "ClientException":
3938
2669
  case "com.amazonaws.ecs#ClientException":
3939
- response = {
3940
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
3941
- name: errorCode,
3942
- $metadata: deserializeMetadata(output),
3943
- };
3944
- break;
2670
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
3945
2671
  case "ClusterNotFoundException":
3946
2672
  case "com.amazonaws.ecs#ClusterNotFoundException":
3947
- response = {
3948
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
3949
- name: errorCode,
3950
- $metadata: deserializeMetadata(output),
3951
- };
3952
- break;
2673
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
3953
2674
  case "InvalidParameterException":
3954
2675
  case "com.amazonaws.ecs#InvalidParameterException":
3955
- response = {
3956
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
3957
- name: errorCode,
3958
- $metadata: deserializeMetadata(output),
3959
- };
3960
- break;
2676
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
3961
2677
  case "ServerException":
3962
2678
  case "com.amazonaws.ecs#ServerException":
3963
- response = {
3964
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
3965
- name: errorCode,
3966
- $metadata: deserializeMetadata(output),
3967
- };
3968
- break;
2679
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
3969
2680
  default:
3970
2681
  const parsedBody = parsedOutput.body;
3971
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
3972
- response = {
3973
- ...parsedBody,
3974
- name: `${errorCode}`,
3975
- message: parsedBody.message || parsedBody.Message || errorCode,
2682
+ response = new ECSServiceException_1.ECSServiceException({
2683
+ name: parsedBody.code || parsedBody.Code || errorCode,
3976
2684
  $fault: "client",
3977
2685
  $metadata: deserializeMetadata(output),
3978
- };
2686
+ });
2687
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
3979
2688
  }
3980
- const message = response.message || response.Message || errorCode;
3981
- response.message = message;
3982
- delete response.Message;
3983
- return Promise.reject(Object.assign(new Error(message), response));
3984
2689
  };
3985
2690
  const deserializeAws_json1_1UpdateContainerAgentCommand = async (output, context) => {
3986
2691
  if (output.statusCode >= 300) {
@@ -4007,75 +2712,34 @@ const deserializeAws_json1_1UpdateContainerAgentCommandError = async (output, co
4007
2712
  switch (errorCode) {
4008
2713
  case "ClientException":
4009
2714
  case "com.amazonaws.ecs#ClientException":
4010
- response = {
4011
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
4012
- name: errorCode,
4013
- $metadata: deserializeMetadata(output),
4014
- };
4015
- break;
2715
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
4016
2716
  case "ClusterNotFoundException":
4017
2717
  case "com.amazonaws.ecs#ClusterNotFoundException":
4018
- response = {
4019
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
4020
- name: errorCode,
4021
- $metadata: deserializeMetadata(output),
4022
- };
4023
- break;
2718
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
4024
2719
  case "InvalidParameterException":
4025
2720
  case "com.amazonaws.ecs#InvalidParameterException":
4026
- response = {
4027
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
4028
- name: errorCode,
4029
- $metadata: deserializeMetadata(output),
4030
- };
4031
- break;
2721
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
4032
2722
  case "MissingVersionException":
4033
2723
  case "com.amazonaws.ecs#MissingVersionException":
4034
- response = {
4035
- ...(await deserializeAws_json1_1MissingVersionExceptionResponse(parsedOutput, context)),
4036
- name: errorCode,
4037
- $metadata: deserializeMetadata(output),
4038
- };
4039
- break;
2724
+ throw await deserializeAws_json1_1MissingVersionExceptionResponse(parsedOutput, context);
4040
2725
  case "NoUpdateAvailableException":
4041
2726
  case "com.amazonaws.ecs#NoUpdateAvailableException":
4042
- response = {
4043
- ...(await deserializeAws_json1_1NoUpdateAvailableExceptionResponse(parsedOutput, context)),
4044
- name: errorCode,
4045
- $metadata: deserializeMetadata(output),
4046
- };
4047
- break;
2727
+ throw await deserializeAws_json1_1NoUpdateAvailableExceptionResponse(parsedOutput, context);
4048
2728
  case "ServerException":
4049
2729
  case "com.amazonaws.ecs#ServerException":
4050
- response = {
4051
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
4052
- name: errorCode,
4053
- $metadata: deserializeMetadata(output),
4054
- };
4055
- break;
2730
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
4056
2731
  case "UpdateInProgressException":
4057
2732
  case "com.amazonaws.ecs#UpdateInProgressException":
4058
- response = {
4059
- ...(await deserializeAws_json1_1UpdateInProgressExceptionResponse(parsedOutput, context)),
4060
- name: errorCode,
4061
- $metadata: deserializeMetadata(output),
4062
- };
4063
- break;
2733
+ throw await deserializeAws_json1_1UpdateInProgressExceptionResponse(parsedOutput, context);
4064
2734
  default:
4065
2735
  const parsedBody = parsedOutput.body;
4066
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4067
- response = {
4068
- ...parsedBody,
4069
- name: `${errorCode}`,
4070
- message: parsedBody.message || parsedBody.Message || errorCode,
2736
+ response = new ECSServiceException_1.ECSServiceException({
2737
+ name: parsedBody.code || parsedBody.Code || errorCode,
4071
2738
  $fault: "client",
4072
2739
  $metadata: deserializeMetadata(output),
4073
- };
2740
+ });
2741
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4074
2742
  }
4075
- const message = response.message || response.Message || errorCode;
4076
- response.message = message;
4077
- delete response.Message;
4078
- return Promise.reject(Object.assign(new Error(message), response));
4079
2743
  };
4080
2744
  const deserializeAws_json1_1UpdateContainerInstancesStateCommand = async (output, context) => {
4081
2745
  if (output.statusCode >= 300) {
@@ -4102,51 +2766,25 @@ const deserializeAws_json1_1UpdateContainerInstancesStateCommandError = async (o
4102
2766
  switch (errorCode) {
4103
2767
  case "ClientException":
4104
2768
  case "com.amazonaws.ecs#ClientException":
4105
- response = {
4106
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
4107
- name: errorCode,
4108
- $metadata: deserializeMetadata(output),
4109
- };
4110
- break;
2769
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
4111
2770
  case "ClusterNotFoundException":
4112
2771
  case "com.amazonaws.ecs#ClusterNotFoundException":
4113
- response = {
4114
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
4115
- name: errorCode,
4116
- $metadata: deserializeMetadata(output),
4117
- };
4118
- break;
2772
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
4119
2773
  case "InvalidParameterException":
4120
2774
  case "com.amazonaws.ecs#InvalidParameterException":
4121
- response = {
4122
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
4123
- name: errorCode,
4124
- $metadata: deserializeMetadata(output),
4125
- };
4126
- break;
2775
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
4127
2776
  case "ServerException":
4128
2777
  case "com.amazonaws.ecs#ServerException":
4129
- response = {
4130
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
4131
- name: errorCode,
4132
- $metadata: deserializeMetadata(output),
4133
- };
4134
- break;
2778
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
4135
2779
  default:
4136
2780
  const parsedBody = parsedOutput.body;
4137
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4138
- response = {
4139
- ...parsedBody,
4140
- name: `${errorCode}`,
4141
- message: parsedBody.message || parsedBody.Message || errorCode,
2781
+ response = new ECSServiceException_1.ECSServiceException({
2782
+ name: parsedBody.code || parsedBody.Code || errorCode,
4142
2783
  $fault: "client",
4143
2784
  $metadata: deserializeMetadata(output),
4144
- };
2785
+ });
2786
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4145
2787
  }
4146
- const message = response.message || response.Message || errorCode;
4147
- response.message = message;
4148
- delete response.Message;
4149
- return Promise.reject(Object.assign(new Error(message), response));
4150
2788
  };
4151
2789
  const deserializeAws_json1_1UpdateServiceCommand = async (output, context) => {
4152
2790
  if (output.statusCode >= 300) {
@@ -4173,91 +2811,40 @@ const deserializeAws_json1_1UpdateServiceCommandError = async (output, context)
4173
2811
  switch (errorCode) {
4174
2812
  case "AccessDeniedException":
4175
2813
  case "com.amazonaws.ecs#AccessDeniedException":
4176
- response = {
4177
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
4178
- name: errorCode,
4179
- $metadata: deserializeMetadata(output),
4180
- };
4181
- break;
2814
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
4182
2815
  case "ClientException":
4183
2816
  case "com.amazonaws.ecs#ClientException":
4184
- response = {
4185
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
4186
- name: errorCode,
4187
- $metadata: deserializeMetadata(output),
4188
- };
4189
- break;
2817
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
4190
2818
  case "ClusterNotFoundException":
4191
2819
  case "com.amazonaws.ecs#ClusterNotFoundException":
4192
- response = {
4193
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
4194
- name: errorCode,
4195
- $metadata: deserializeMetadata(output),
4196
- };
4197
- break;
2820
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
4198
2821
  case "InvalidParameterException":
4199
2822
  case "com.amazonaws.ecs#InvalidParameterException":
4200
- response = {
4201
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
4202
- name: errorCode,
4203
- $metadata: deserializeMetadata(output),
4204
- };
4205
- break;
2823
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
4206
2824
  case "PlatformTaskDefinitionIncompatibilityException":
4207
2825
  case "com.amazonaws.ecs#PlatformTaskDefinitionIncompatibilityException":
4208
- response = {
4209
- ...(await deserializeAws_json1_1PlatformTaskDefinitionIncompatibilityExceptionResponse(parsedOutput, context)),
4210
- name: errorCode,
4211
- $metadata: deserializeMetadata(output),
4212
- };
4213
- break;
2826
+ throw await deserializeAws_json1_1PlatformTaskDefinitionIncompatibilityExceptionResponse(parsedOutput, context);
4214
2827
  case "PlatformUnknownException":
4215
2828
  case "com.amazonaws.ecs#PlatformUnknownException":
4216
- response = {
4217
- ...(await deserializeAws_json1_1PlatformUnknownExceptionResponse(parsedOutput, context)),
4218
- name: errorCode,
4219
- $metadata: deserializeMetadata(output),
4220
- };
4221
- break;
2829
+ throw await deserializeAws_json1_1PlatformUnknownExceptionResponse(parsedOutput, context);
4222
2830
  case "ServerException":
4223
2831
  case "com.amazonaws.ecs#ServerException":
4224
- response = {
4225
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
4226
- name: errorCode,
4227
- $metadata: deserializeMetadata(output),
4228
- };
4229
- break;
2832
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
4230
2833
  case "ServiceNotActiveException":
4231
2834
  case "com.amazonaws.ecs#ServiceNotActiveException":
4232
- response = {
4233
- ...(await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context)),
4234
- name: errorCode,
4235
- $metadata: deserializeMetadata(output),
4236
- };
4237
- break;
2835
+ throw await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context);
4238
2836
  case "ServiceNotFoundException":
4239
2837
  case "com.amazonaws.ecs#ServiceNotFoundException":
4240
- response = {
4241
- ...(await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context)),
4242
- name: errorCode,
4243
- $metadata: deserializeMetadata(output),
4244
- };
4245
- break;
2838
+ throw await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context);
4246
2839
  default:
4247
2840
  const parsedBody = parsedOutput.body;
4248
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4249
- response = {
4250
- ...parsedBody,
4251
- name: `${errorCode}`,
4252
- message: parsedBody.message || parsedBody.Message || errorCode,
2841
+ response = new ECSServiceException_1.ECSServiceException({
2842
+ name: parsedBody.code || parsedBody.Code || errorCode,
4253
2843
  $fault: "client",
4254
2844
  $metadata: deserializeMetadata(output),
4255
- };
2845
+ });
2846
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4256
2847
  }
4257
- const message = response.message || response.Message || errorCode;
4258
- response.message = message;
4259
- delete response.Message;
4260
- return Promise.reject(Object.assign(new Error(message), response));
4261
2848
  };
4262
2849
  const deserializeAws_json1_1UpdateServicePrimaryTaskSetCommand = async (output, context) => {
4263
2850
  if (output.statusCode >= 300) {
@@ -4284,91 +2871,40 @@ const deserializeAws_json1_1UpdateServicePrimaryTaskSetCommandError = async (out
4284
2871
  switch (errorCode) {
4285
2872
  case "AccessDeniedException":
4286
2873
  case "com.amazonaws.ecs#AccessDeniedException":
4287
- response = {
4288
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
4289
- name: errorCode,
4290
- $metadata: deserializeMetadata(output),
4291
- };
4292
- break;
2874
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
4293
2875
  case "ClientException":
4294
2876
  case "com.amazonaws.ecs#ClientException":
4295
- response = {
4296
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
4297
- name: errorCode,
4298
- $metadata: deserializeMetadata(output),
4299
- };
4300
- break;
2877
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
4301
2878
  case "ClusterNotFoundException":
4302
2879
  case "com.amazonaws.ecs#ClusterNotFoundException":
4303
- response = {
4304
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
4305
- name: errorCode,
4306
- $metadata: deserializeMetadata(output),
4307
- };
4308
- break;
2880
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
4309
2881
  case "InvalidParameterException":
4310
2882
  case "com.amazonaws.ecs#InvalidParameterException":
4311
- response = {
4312
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
4313
- name: errorCode,
4314
- $metadata: deserializeMetadata(output),
4315
- };
4316
- break;
2883
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
4317
2884
  case "ServerException":
4318
2885
  case "com.amazonaws.ecs#ServerException":
4319
- response = {
4320
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
4321
- name: errorCode,
4322
- $metadata: deserializeMetadata(output),
4323
- };
4324
- break;
2886
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
4325
2887
  case "ServiceNotActiveException":
4326
2888
  case "com.amazonaws.ecs#ServiceNotActiveException":
4327
- response = {
4328
- ...(await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context)),
4329
- name: errorCode,
4330
- $metadata: deserializeMetadata(output),
4331
- };
4332
- break;
2889
+ throw await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context);
4333
2890
  case "ServiceNotFoundException":
4334
2891
  case "com.amazonaws.ecs#ServiceNotFoundException":
4335
- response = {
4336
- ...(await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context)),
4337
- name: errorCode,
4338
- $metadata: deserializeMetadata(output),
4339
- };
4340
- break;
2892
+ throw await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context);
4341
2893
  case "TaskSetNotFoundException":
4342
2894
  case "com.amazonaws.ecs#TaskSetNotFoundException":
4343
- response = {
4344
- ...(await deserializeAws_json1_1TaskSetNotFoundExceptionResponse(parsedOutput, context)),
4345
- name: errorCode,
4346
- $metadata: deserializeMetadata(output),
4347
- };
4348
- break;
2895
+ throw await deserializeAws_json1_1TaskSetNotFoundExceptionResponse(parsedOutput, context);
4349
2896
  case "UnsupportedFeatureException":
4350
2897
  case "com.amazonaws.ecs#UnsupportedFeatureException":
4351
- response = {
4352
- ...(await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context)),
4353
- name: errorCode,
4354
- $metadata: deserializeMetadata(output),
4355
- };
4356
- break;
2898
+ throw await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context);
4357
2899
  default:
4358
2900
  const parsedBody = parsedOutput.body;
4359
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4360
- response = {
4361
- ...parsedBody,
4362
- name: `${errorCode}`,
4363
- message: parsedBody.message || parsedBody.Message || errorCode,
2901
+ response = new ECSServiceException_1.ECSServiceException({
2902
+ name: parsedBody.code || parsedBody.Code || errorCode,
4364
2903
  $fault: "client",
4365
2904
  $metadata: deserializeMetadata(output),
4366
- };
2905
+ });
2906
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4367
2907
  }
4368
- const message = response.message || response.Message || errorCode;
4369
- response.message = message;
4370
- delete response.Message;
4371
- return Promise.reject(Object.assign(new Error(message), response));
4372
2908
  };
4373
2909
  const deserializeAws_json1_1UpdateTaskSetCommand = async (output, context) => {
4374
2910
  if (output.statusCode >= 300) {
@@ -4395,355 +2931,256 @@ const deserializeAws_json1_1UpdateTaskSetCommandError = async (output, context)
4395
2931
  switch (errorCode) {
4396
2932
  case "AccessDeniedException":
4397
2933
  case "com.amazonaws.ecs#AccessDeniedException":
4398
- response = {
4399
- ...(await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context)),
4400
- name: errorCode,
4401
- $metadata: deserializeMetadata(output),
4402
- };
4403
- break;
2934
+ throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
4404
2935
  case "ClientException":
4405
2936
  case "com.amazonaws.ecs#ClientException":
4406
- response = {
4407
- ...(await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context)),
4408
- name: errorCode,
4409
- $metadata: deserializeMetadata(output),
4410
- };
4411
- break;
2937
+ throw await deserializeAws_json1_1ClientExceptionResponse(parsedOutput, context);
4412
2938
  case "ClusterNotFoundException":
4413
2939
  case "com.amazonaws.ecs#ClusterNotFoundException":
4414
- response = {
4415
- ...(await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context)),
4416
- name: errorCode,
4417
- $metadata: deserializeMetadata(output),
4418
- };
4419
- break;
2940
+ throw await deserializeAws_json1_1ClusterNotFoundExceptionResponse(parsedOutput, context);
4420
2941
  case "InvalidParameterException":
4421
2942
  case "com.amazonaws.ecs#InvalidParameterException":
4422
- response = {
4423
- ...(await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context)),
4424
- name: errorCode,
4425
- $metadata: deserializeMetadata(output),
4426
- };
4427
- break;
2943
+ throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
4428
2944
  case "ServerException":
4429
2945
  case "com.amazonaws.ecs#ServerException":
4430
- response = {
4431
- ...(await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context)),
4432
- name: errorCode,
4433
- $metadata: deserializeMetadata(output),
4434
- };
4435
- break;
2946
+ throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
4436
2947
  case "ServiceNotActiveException":
4437
2948
  case "com.amazonaws.ecs#ServiceNotActiveException":
4438
- response = {
4439
- ...(await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context)),
4440
- name: errorCode,
4441
- $metadata: deserializeMetadata(output),
4442
- };
4443
- break;
2949
+ throw await deserializeAws_json1_1ServiceNotActiveExceptionResponse(parsedOutput, context);
4444
2950
  case "ServiceNotFoundException":
4445
2951
  case "com.amazonaws.ecs#ServiceNotFoundException":
4446
- response = {
4447
- ...(await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context)),
4448
- name: errorCode,
4449
- $metadata: deserializeMetadata(output),
4450
- };
4451
- break;
2952
+ throw await deserializeAws_json1_1ServiceNotFoundExceptionResponse(parsedOutput, context);
4452
2953
  case "TaskSetNotFoundException":
4453
2954
  case "com.amazonaws.ecs#TaskSetNotFoundException":
4454
- response = {
4455
- ...(await deserializeAws_json1_1TaskSetNotFoundExceptionResponse(parsedOutput, context)),
4456
- name: errorCode,
4457
- $metadata: deserializeMetadata(output),
4458
- };
4459
- break;
2955
+ throw await deserializeAws_json1_1TaskSetNotFoundExceptionResponse(parsedOutput, context);
4460
2956
  case "UnsupportedFeatureException":
4461
2957
  case "com.amazonaws.ecs#UnsupportedFeatureException":
4462
- response = {
4463
- ...(await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context)),
4464
- name: errorCode,
4465
- $metadata: deserializeMetadata(output),
4466
- };
4467
- break;
2958
+ throw await deserializeAws_json1_1UnsupportedFeatureExceptionResponse(parsedOutput, context);
4468
2959
  default:
4469
2960
  const parsedBody = parsedOutput.body;
4470
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
4471
- response = {
4472
- ...parsedBody,
4473
- name: `${errorCode}`,
4474
- message: parsedBody.message || parsedBody.Message || errorCode,
2961
+ response = new ECSServiceException_1.ECSServiceException({
2962
+ name: parsedBody.code || parsedBody.Code || errorCode,
4475
2963
  $fault: "client",
4476
2964
  $metadata: deserializeMetadata(output),
4477
- };
2965
+ });
2966
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
4478
2967
  }
4479
- const message = response.message || response.Message || errorCode;
4480
- response.message = message;
4481
- delete response.Message;
4482
- return Promise.reject(Object.assign(new Error(message), response));
4483
2968
  };
4484
2969
  const deserializeAws_json1_1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
4485
2970
  const body = parsedOutput.body;
4486
2971
  const deserialized = deserializeAws_json1_1AccessDeniedException(body, context);
4487
- const contents = {
4488
- name: "AccessDeniedException",
4489
- $fault: "client",
2972
+ const exception = new models_0_1.AccessDeniedException({
4490
2973
  $metadata: deserializeMetadata(parsedOutput),
4491
2974
  ...deserialized,
4492
- };
4493
- return contents;
2975
+ });
2976
+ return smithy_client_1.decorateServiceException(exception, body);
4494
2977
  };
4495
2978
  const deserializeAws_json1_1AttributeLimitExceededExceptionResponse = async (parsedOutput, context) => {
4496
2979
  const body = parsedOutput.body;
4497
2980
  const deserialized = deserializeAws_json1_1AttributeLimitExceededException(body, context);
4498
- const contents = {
4499
- name: "AttributeLimitExceededException",
4500
- $fault: "client",
2981
+ const exception = new models_0_1.AttributeLimitExceededException({
4501
2982
  $metadata: deserializeMetadata(parsedOutput),
4502
2983
  ...deserialized,
4503
- };
4504
- return contents;
2984
+ });
2985
+ return smithy_client_1.decorateServiceException(exception, body);
4505
2986
  };
4506
2987
  const deserializeAws_json1_1BlockedExceptionResponse = async (parsedOutput, context) => {
4507
2988
  const body = parsedOutput.body;
4508
2989
  const deserialized = deserializeAws_json1_1BlockedException(body, context);
4509
- const contents = {
4510
- name: "BlockedException",
4511
- $fault: "client",
2990
+ const exception = new models_0_1.BlockedException({
4512
2991
  $metadata: deserializeMetadata(parsedOutput),
4513
2992
  ...deserialized,
4514
- };
4515
- return contents;
2993
+ });
2994
+ return smithy_client_1.decorateServiceException(exception, body);
4516
2995
  };
4517
2996
  const deserializeAws_json1_1ClientExceptionResponse = async (parsedOutput, context) => {
4518
2997
  const body = parsedOutput.body;
4519
2998
  const deserialized = deserializeAws_json1_1ClientException(body, context);
4520
- const contents = {
4521
- name: "ClientException",
4522
- $fault: "client",
2999
+ const exception = new models_0_1.ClientException({
4523
3000
  $metadata: deserializeMetadata(parsedOutput),
4524
3001
  ...deserialized,
4525
- };
4526
- return contents;
3002
+ });
3003
+ return smithy_client_1.decorateServiceException(exception, body);
4527
3004
  };
4528
3005
  const deserializeAws_json1_1ClusterContainsContainerInstancesExceptionResponse = async (parsedOutput, context) => {
4529
3006
  const body = parsedOutput.body;
4530
3007
  const deserialized = deserializeAws_json1_1ClusterContainsContainerInstancesException(body, context);
4531
- const contents = {
4532
- name: "ClusterContainsContainerInstancesException",
4533
- $fault: "client",
3008
+ const exception = new models_0_1.ClusterContainsContainerInstancesException({
4534
3009
  $metadata: deserializeMetadata(parsedOutput),
4535
3010
  ...deserialized,
4536
- };
4537
- return contents;
3011
+ });
3012
+ return smithy_client_1.decorateServiceException(exception, body);
4538
3013
  };
4539
3014
  const deserializeAws_json1_1ClusterContainsServicesExceptionResponse = async (parsedOutput, context) => {
4540
3015
  const body = parsedOutput.body;
4541
3016
  const deserialized = deserializeAws_json1_1ClusterContainsServicesException(body, context);
4542
- const contents = {
4543
- name: "ClusterContainsServicesException",
4544
- $fault: "client",
3017
+ const exception = new models_0_1.ClusterContainsServicesException({
4545
3018
  $metadata: deserializeMetadata(parsedOutput),
4546
3019
  ...deserialized,
4547
- };
4548
- return contents;
3020
+ });
3021
+ return smithy_client_1.decorateServiceException(exception, body);
4549
3022
  };
4550
3023
  const deserializeAws_json1_1ClusterContainsTasksExceptionResponse = async (parsedOutput, context) => {
4551
3024
  const body = parsedOutput.body;
4552
3025
  const deserialized = deserializeAws_json1_1ClusterContainsTasksException(body, context);
4553
- const contents = {
4554
- name: "ClusterContainsTasksException",
4555
- $fault: "client",
3026
+ const exception = new models_0_1.ClusterContainsTasksException({
4556
3027
  $metadata: deserializeMetadata(parsedOutput),
4557
3028
  ...deserialized,
4558
- };
4559
- return contents;
3029
+ });
3030
+ return smithy_client_1.decorateServiceException(exception, body);
4560
3031
  };
4561
3032
  const deserializeAws_json1_1ClusterNotFoundExceptionResponse = async (parsedOutput, context) => {
4562
3033
  const body = parsedOutput.body;
4563
3034
  const deserialized = deserializeAws_json1_1ClusterNotFoundException(body, context);
4564
- const contents = {
4565
- name: "ClusterNotFoundException",
4566
- $fault: "client",
3035
+ const exception = new models_0_1.ClusterNotFoundException({
4567
3036
  $metadata: deserializeMetadata(parsedOutput),
4568
3037
  ...deserialized,
4569
- };
4570
- return contents;
3038
+ });
3039
+ return smithy_client_1.decorateServiceException(exception, body);
4571
3040
  };
4572
3041
  const deserializeAws_json1_1InvalidParameterExceptionResponse = async (parsedOutput, context) => {
4573
3042
  const body = parsedOutput.body;
4574
3043
  const deserialized = deserializeAws_json1_1InvalidParameterException(body, context);
4575
- const contents = {
4576
- name: "InvalidParameterException",
4577
- $fault: "client",
3044
+ const exception = new models_0_1.InvalidParameterException({
4578
3045
  $metadata: deserializeMetadata(parsedOutput),
4579
3046
  ...deserialized,
4580
- };
4581
- return contents;
3047
+ });
3048
+ return smithy_client_1.decorateServiceException(exception, body);
4582
3049
  };
4583
3050
  const deserializeAws_json1_1LimitExceededExceptionResponse = async (parsedOutput, context) => {
4584
3051
  const body = parsedOutput.body;
4585
3052
  const deserialized = deserializeAws_json1_1LimitExceededException(body, context);
4586
- const contents = {
4587
- name: "LimitExceededException",
4588
- $fault: "client",
3053
+ const exception = new models_0_1.LimitExceededException({
4589
3054
  $metadata: deserializeMetadata(parsedOutput),
4590
3055
  ...deserialized,
4591
- };
4592
- return contents;
3056
+ });
3057
+ return smithy_client_1.decorateServiceException(exception, body);
4593
3058
  };
4594
3059
  const deserializeAws_json1_1MissingVersionExceptionResponse = async (parsedOutput, context) => {
4595
3060
  const body = parsedOutput.body;
4596
3061
  const deserialized = deserializeAws_json1_1MissingVersionException(body, context);
4597
- const contents = {
4598
- name: "MissingVersionException",
4599
- $fault: "client",
3062
+ const exception = new models_0_1.MissingVersionException({
4600
3063
  $metadata: deserializeMetadata(parsedOutput),
4601
3064
  ...deserialized,
4602
- };
4603
- return contents;
3065
+ });
3066
+ return smithy_client_1.decorateServiceException(exception, body);
4604
3067
  };
4605
3068
  const deserializeAws_json1_1NoUpdateAvailableExceptionResponse = async (parsedOutput, context) => {
4606
3069
  const body = parsedOutput.body;
4607
3070
  const deserialized = deserializeAws_json1_1NoUpdateAvailableException(body, context);
4608
- const contents = {
4609
- name: "NoUpdateAvailableException",
4610
- $fault: "client",
3071
+ const exception = new models_0_1.NoUpdateAvailableException({
4611
3072
  $metadata: deserializeMetadata(parsedOutput),
4612
3073
  ...deserialized,
4613
- };
4614
- return contents;
3074
+ });
3075
+ return smithy_client_1.decorateServiceException(exception, body);
4615
3076
  };
4616
3077
  const deserializeAws_json1_1PlatformTaskDefinitionIncompatibilityExceptionResponse = async (parsedOutput, context) => {
4617
3078
  const body = parsedOutput.body;
4618
3079
  const deserialized = deserializeAws_json1_1PlatformTaskDefinitionIncompatibilityException(body, context);
4619
- const contents = {
4620
- name: "PlatformTaskDefinitionIncompatibilityException",
4621
- $fault: "client",
3080
+ const exception = new models_0_1.PlatformTaskDefinitionIncompatibilityException({
4622
3081
  $metadata: deserializeMetadata(parsedOutput),
4623
3082
  ...deserialized,
4624
- };
4625
- return contents;
3083
+ });
3084
+ return smithy_client_1.decorateServiceException(exception, body);
4626
3085
  };
4627
3086
  const deserializeAws_json1_1PlatformUnknownExceptionResponse = async (parsedOutput, context) => {
4628
3087
  const body = parsedOutput.body;
4629
3088
  const deserialized = deserializeAws_json1_1PlatformUnknownException(body, context);
4630
- const contents = {
4631
- name: "PlatformUnknownException",
4632
- $fault: "client",
3089
+ const exception = new models_0_1.PlatformUnknownException({
4633
3090
  $metadata: deserializeMetadata(parsedOutput),
4634
3091
  ...deserialized,
4635
- };
4636
- return contents;
3092
+ });
3093
+ return smithy_client_1.decorateServiceException(exception, body);
4637
3094
  };
4638
3095
  const deserializeAws_json1_1ResourceInUseExceptionResponse = async (parsedOutput, context) => {
4639
3096
  const body = parsedOutput.body;
4640
3097
  const deserialized = deserializeAws_json1_1ResourceInUseException(body, context);
4641
- const contents = {
4642
- name: "ResourceInUseException",
4643
- $fault: "client",
3098
+ const exception = new models_0_1.ResourceInUseException({
4644
3099
  $metadata: deserializeMetadata(parsedOutput),
4645
3100
  ...deserialized,
4646
- };
4647
- return contents;
3101
+ });
3102
+ return smithy_client_1.decorateServiceException(exception, body);
4648
3103
  };
4649
3104
  const deserializeAws_json1_1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
4650
3105
  const body = parsedOutput.body;
4651
3106
  const deserialized = deserializeAws_json1_1ResourceNotFoundException(body, context);
4652
- const contents = {
4653
- name: "ResourceNotFoundException",
4654
- $fault: "client",
3107
+ const exception = new models_0_1.ResourceNotFoundException({
4655
3108
  $metadata: deserializeMetadata(parsedOutput),
4656
3109
  ...deserialized,
4657
- };
4658
- return contents;
3110
+ });
3111
+ return smithy_client_1.decorateServiceException(exception, body);
4659
3112
  };
4660
3113
  const deserializeAws_json1_1ServerExceptionResponse = async (parsedOutput, context) => {
4661
3114
  const body = parsedOutput.body;
4662
3115
  const deserialized = deserializeAws_json1_1ServerException(body, context);
4663
- const contents = {
4664
- name: "ServerException",
4665
- $fault: "server",
3116
+ const exception = new models_0_1.ServerException({
4666
3117
  $metadata: deserializeMetadata(parsedOutput),
4667
3118
  ...deserialized,
4668
- };
4669
- return contents;
3119
+ });
3120
+ return smithy_client_1.decorateServiceException(exception, body);
4670
3121
  };
4671
3122
  const deserializeAws_json1_1ServiceNotActiveExceptionResponse = async (parsedOutput, context) => {
4672
3123
  const body = parsedOutput.body;
4673
3124
  const deserialized = deserializeAws_json1_1ServiceNotActiveException(body, context);
4674
- const contents = {
4675
- name: "ServiceNotActiveException",
4676
- $fault: "client",
3125
+ const exception = new models_0_1.ServiceNotActiveException({
4677
3126
  $metadata: deserializeMetadata(parsedOutput),
4678
3127
  ...deserialized,
4679
- };
4680
- return contents;
3128
+ });
3129
+ return smithy_client_1.decorateServiceException(exception, body);
4681
3130
  };
4682
3131
  const deserializeAws_json1_1ServiceNotFoundExceptionResponse = async (parsedOutput, context) => {
4683
3132
  const body = parsedOutput.body;
4684
3133
  const deserialized = deserializeAws_json1_1ServiceNotFoundException(body, context);
4685
- const contents = {
4686
- name: "ServiceNotFoundException",
4687
- $fault: "client",
3134
+ const exception = new models_0_1.ServiceNotFoundException({
4688
3135
  $metadata: deserializeMetadata(parsedOutput),
4689
3136
  ...deserialized,
4690
- };
4691
- return contents;
3137
+ });
3138
+ return smithy_client_1.decorateServiceException(exception, body);
4692
3139
  };
4693
3140
  const deserializeAws_json1_1TargetNotConnectedExceptionResponse = async (parsedOutput, context) => {
4694
3141
  const body = parsedOutput.body;
4695
3142
  const deserialized = deserializeAws_json1_1TargetNotConnectedException(body, context);
4696
- const contents = {
4697
- name: "TargetNotConnectedException",
4698
- $fault: "client",
3143
+ const exception = new models_0_1.TargetNotConnectedException({
4699
3144
  $metadata: deserializeMetadata(parsedOutput),
4700
3145
  ...deserialized,
4701
- };
4702
- return contents;
3146
+ });
3147
+ return smithy_client_1.decorateServiceException(exception, body);
4703
3148
  };
4704
3149
  const deserializeAws_json1_1TargetNotFoundExceptionResponse = async (parsedOutput, context) => {
4705
3150
  const body = parsedOutput.body;
4706
3151
  const deserialized = deserializeAws_json1_1TargetNotFoundException(body, context);
4707
- const contents = {
4708
- name: "TargetNotFoundException",
4709
- $fault: "client",
3152
+ const exception = new models_0_1.TargetNotFoundException({
4710
3153
  $metadata: deserializeMetadata(parsedOutput),
4711
3154
  ...deserialized,
4712
- };
4713
- return contents;
3155
+ });
3156
+ return smithy_client_1.decorateServiceException(exception, body);
4714
3157
  };
4715
3158
  const deserializeAws_json1_1TaskSetNotFoundExceptionResponse = async (parsedOutput, context) => {
4716
3159
  const body = parsedOutput.body;
4717
3160
  const deserialized = deserializeAws_json1_1TaskSetNotFoundException(body, context);
4718
- const contents = {
4719
- name: "TaskSetNotFoundException",
4720
- $fault: "client",
3161
+ const exception = new models_0_1.TaskSetNotFoundException({
4721
3162
  $metadata: deserializeMetadata(parsedOutput),
4722
3163
  ...deserialized,
4723
- };
4724
- return contents;
3164
+ });
3165
+ return smithy_client_1.decorateServiceException(exception, body);
4725
3166
  };
4726
3167
  const deserializeAws_json1_1UnsupportedFeatureExceptionResponse = async (parsedOutput, context) => {
4727
3168
  const body = parsedOutput.body;
4728
3169
  const deserialized = deserializeAws_json1_1UnsupportedFeatureException(body, context);
4729
- const contents = {
4730
- name: "UnsupportedFeatureException",
4731
- $fault: "client",
3170
+ const exception = new models_0_1.UnsupportedFeatureException({
4732
3171
  $metadata: deserializeMetadata(parsedOutput),
4733
3172
  ...deserialized,
4734
- };
4735
- return contents;
3173
+ });
3174
+ return smithy_client_1.decorateServiceException(exception, body);
4736
3175
  };
4737
3176
  const deserializeAws_json1_1UpdateInProgressExceptionResponse = async (parsedOutput, context) => {
4738
3177
  const body = parsedOutput.body;
4739
3178
  const deserialized = deserializeAws_json1_1UpdateInProgressException(body, context);
4740
- const contents = {
4741
- name: "UpdateInProgressException",
4742
- $fault: "client",
3179
+ const exception = new models_0_1.UpdateInProgressException({
4743
3180
  $metadata: deserializeMetadata(parsedOutput),
4744
3181
  ...deserialized,
4745
- };
4746
- return contents;
3182
+ });
3183
+ return smithy_client_1.decorateServiceException(exception, body);
4747
3184
  };
4748
3185
  const serializeAws_json1_1AttachmentStateChange = (input, context) => {
4749
3186
  return {
@@ -6572,7 +5009,7 @@ const deserializeAws_json1_1Attachment = (output, context) => {
6572
5009
  };
6573
5010
  };
6574
5011
  const deserializeAws_json1_1AttachmentDetails = (output, context) => {
6575
- return (output || [])
5012
+ const retVal = (output || [])
6576
5013
  .filter((e) => e != null)
6577
5014
  .map((entry) => {
6578
5015
  if (entry === null) {
@@ -6580,9 +5017,10 @@ const deserializeAws_json1_1AttachmentDetails = (output, context) => {
6580
5017
  }
6581
5018
  return deserializeAws_json1_1KeyValuePair(entry, context);
6582
5019
  });
5020
+ return retVal;
6583
5021
  };
6584
5022
  const deserializeAws_json1_1Attachments = (output, context) => {
6585
- return (output || [])
5023
+ const retVal = (output || [])
6586
5024
  .filter((e) => e != null)
6587
5025
  .map((entry) => {
6588
5026
  if (entry === null) {
@@ -6590,6 +5028,7 @@ const deserializeAws_json1_1Attachments = (output, context) => {
6590
5028
  }
6591
5029
  return deserializeAws_json1_1Attachment(entry, context);
6592
5030
  });
5031
+ return retVal;
6593
5032
  };
6594
5033
  const deserializeAws_json1_1Attribute = (output, context) => {
6595
5034
  return {
@@ -6605,7 +5044,7 @@ const deserializeAws_json1_1AttributeLimitExceededException = (output, context)
6605
5044
  };
6606
5045
  };
6607
5046
  const deserializeAws_json1_1Attributes = (output, context) => {
6608
- return (output || [])
5047
+ const retVal = (output || [])
6609
5048
  .filter((e) => e != null)
6610
5049
  .map((entry) => {
6611
5050
  if (entry === null) {
@@ -6613,6 +5052,7 @@ const deserializeAws_json1_1Attributes = (output, context) => {
6613
5052
  }
6614
5053
  return deserializeAws_json1_1Attribute(entry, context);
6615
5054
  });
5055
+ return retVal;
6616
5056
  };
6617
5057
  const deserializeAws_json1_1AutoScalingGroupProvider = (output, context) => {
6618
5058
  return {
@@ -6653,7 +5093,7 @@ const deserializeAws_json1_1CapacityProvider = (output, context) => {
6653
5093
  };
6654
5094
  };
6655
5095
  const deserializeAws_json1_1CapacityProviders = (output, context) => {
6656
- return (output || [])
5096
+ const retVal = (output || [])
6657
5097
  .filter((e) => e != null)
6658
5098
  .map((entry) => {
6659
5099
  if (entry === null) {
@@ -6661,9 +5101,10 @@ const deserializeAws_json1_1CapacityProviders = (output, context) => {
6661
5101
  }
6662
5102
  return deserializeAws_json1_1CapacityProvider(entry, context);
6663
5103
  });
5104
+ return retVal;
6664
5105
  };
6665
5106
  const deserializeAws_json1_1CapacityProviderStrategy = (output, context) => {
6666
- return (output || [])
5107
+ const retVal = (output || [])
6667
5108
  .filter((e) => e != null)
6668
5109
  .map((entry) => {
6669
5110
  if (entry === null) {
@@ -6671,6 +5112,7 @@ const deserializeAws_json1_1CapacityProviderStrategy = (output, context) => {
6671
5112
  }
6672
5113
  return deserializeAws_json1_1CapacityProviderStrategyItem(entry, context);
6673
5114
  });
5115
+ return retVal;
6674
5116
  };
6675
5117
  const deserializeAws_json1_1CapacityProviderStrategyItem = (output, context) => {
6676
5118
  return {
@@ -6743,7 +5185,7 @@ const deserializeAws_json1_1ClusterNotFoundException = (output, context) => {
6743
5185
  };
6744
5186
  };
6745
5187
  const deserializeAws_json1_1Clusters = (output, context) => {
6746
- return (output || [])
5188
+ const retVal = (output || [])
6747
5189
  .filter((e) => e != null)
6748
5190
  .map((entry) => {
6749
5191
  if (entry === null) {
@@ -6751,6 +5193,7 @@ const deserializeAws_json1_1Clusters = (output, context) => {
6751
5193
  }
6752
5194
  return deserializeAws_json1_1Cluster(entry, context);
6753
5195
  });
5196
+ return retVal;
6754
5197
  };
6755
5198
  const deserializeAws_json1_1ClusterSetting = (output, context) => {
6756
5199
  return {
@@ -6759,7 +5202,7 @@ const deserializeAws_json1_1ClusterSetting = (output, context) => {
6759
5202
  };
6760
5203
  };
6761
5204
  const deserializeAws_json1_1ClusterSettings = (output, context) => {
6762
- return (output || [])
5205
+ const retVal = (output || [])
6763
5206
  .filter((e) => e != null)
6764
5207
  .map((entry) => {
6765
5208
  if (entry === null) {
@@ -6767,9 +5210,10 @@ const deserializeAws_json1_1ClusterSettings = (output, context) => {
6767
5210
  }
6768
5211
  return deserializeAws_json1_1ClusterSetting(entry, context);
6769
5212
  });
5213
+ return retVal;
6770
5214
  };
6771
5215
  const deserializeAws_json1_1CompatibilityList = (output, context) => {
6772
- return (output || [])
5216
+ const retVal = (output || [])
6773
5217
  .filter((e) => e != null)
6774
5218
  .map((entry) => {
6775
5219
  if (entry === null) {
@@ -6777,6 +5221,7 @@ const deserializeAws_json1_1CompatibilityList = (output, context) => {
6777
5221
  }
6778
5222
  return smithy_client_1.expectString(entry);
6779
5223
  });
5224
+ return retVal;
6780
5225
  };
6781
5226
  const deserializeAws_json1_1Container = (output, context) => {
6782
5227
  return {
@@ -6897,7 +5342,7 @@ const deserializeAws_json1_1ContainerDefinition = (output, context) => {
6897
5342
  };
6898
5343
  };
6899
5344
  const deserializeAws_json1_1ContainerDefinitions = (output, context) => {
6900
- return (output || [])
5345
+ const retVal = (output || [])
6901
5346
  .filter((e) => e != null)
6902
5347
  .map((entry) => {
6903
5348
  if (entry === null) {
@@ -6905,9 +5350,10 @@ const deserializeAws_json1_1ContainerDefinitions = (output, context) => {
6905
5350
  }
6906
5351
  return deserializeAws_json1_1ContainerDefinition(entry, context);
6907
5352
  });
5353
+ return retVal;
6908
5354
  };
6909
5355
  const deserializeAws_json1_1ContainerDependencies = (output, context) => {
6910
- return (output || [])
5356
+ const retVal = (output || [])
6911
5357
  .filter((e) => e != null)
6912
5358
  .map((entry) => {
6913
5359
  if (entry === null) {
@@ -6915,6 +5361,7 @@ const deserializeAws_json1_1ContainerDependencies = (output, context) => {
6915
5361
  }
6916
5362
  return deserializeAws_json1_1ContainerDependency(entry, context);
6917
5363
  });
5364
+ return retVal;
6918
5365
  };
6919
5366
  const deserializeAws_json1_1ContainerDependency = (output, context) => {
6920
5367
  return {
@@ -6967,7 +5414,7 @@ const deserializeAws_json1_1ContainerInstanceHealthStatus = (output, context) =>
6967
5414
  };
6968
5415
  };
6969
5416
  const deserializeAws_json1_1ContainerInstances = (output, context) => {
6970
- return (output || [])
5417
+ const retVal = (output || [])
6971
5418
  .filter((e) => e != null)
6972
5419
  .map((entry) => {
6973
5420
  if (entry === null) {
@@ -6975,6 +5422,7 @@ const deserializeAws_json1_1ContainerInstances = (output, context) => {
6975
5422
  }
6976
5423
  return deserializeAws_json1_1ContainerInstance(entry, context);
6977
5424
  });
5425
+ return retVal;
6978
5426
  };
6979
5427
  const deserializeAws_json1_1ContainerOverride = (output, context) => {
6980
5428
  return {
@@ -6997,7 +5445,7 @@ const deserializeAws_json1_1ContainerOverride = (output, context) => {
6997
5445
  };
6998
5446
  };
6999
5447
  const deserializeAws_json1_1ContainerOverrides = (output, context) => {
7000
- return (output || [])
5448
+ const retVal = (output || [])
7001
5449
  .filter((e) => e != null)
7002
5450
  .map((entry) => {
7003
5451
  if (entry === null) {
@@ -7005,9 +5453,10 @@ const deserializeAws_json1_1ContainerOverrides = (output, context) => {
7005
5453
  }
7006
5454
  return deserializeAws_json1_1ContainerOverride(entry, context);
7007
5455
  });
5456
+ return retVal;
7008
5457
  };
7009
5458
  const deserializeAws_json1_1Containers = (output, context) => {
7010
- return (output || [])
5459
+ const retVal = (output || [])
7011
5460
  .filter((e) => e != null)
7012
5461
  .map((entry) => {
7013
5462
  if (entry === null) {
@@ -7015,6 +5464,7 @@ const deserializeAws_json1_1Containers = (output, context) => {
7015
5464
  }
7016
5465
  return deserializeAws_json1_1Container(entry, context);
7017
5466
  });
5467
+ return retVal;
7018
5468
  };
7019
5469
  const deserializeAws_json1_1CreateCapacityProviderResponse = (output, context) => {
7020
5470
  return {
@@ -7135,7 +5585,7 @@ const deserializeAws_json1_1DeploymentController = (output, context) => {
7135
5585
  };
7136
5586
  };
7137
5587
  const deserializeAws_json1_1Deployments = (output, context) => {
7138
- return (output || [])
5588
+ const retVal = (output || [])
7139
5589
  .filter((e) => e != null)
7140
5590
  .map((entry) => {
7141
5591
  if (entry === null) {
@@ -7143,6 +5593,7 @@ const deserializeAws_json1_1Deployments = (output, context) => {
7143
5593
  }
7144
5594
  return deserializeAws_json1_1Deployment(entry, context);
7145
5595
  });
5596
+ return retVal;
7146
5597
  };
7147
5598
  const deserializeAws_json1_1DeregisterContainerInstanceResponse = (output, context) => {
7148
5599
  return {
@@ -7237,7 +5688,7 @@ const deserializeAws_json1_1Device = (output, context) => {
7237
5688
  };
7238
5689
  };
7239
5690
  const deserializeAws_json1_1DeviceCgroupPermissions = (output, context) => {
7240
- return (output || [])
5691
+ const retVal = (output || [])
7241
5692
  .filter((e) => e != null)
7242
5693
  .map((entry) => {
7243
5694
  if (entry === null) {
@@ -7245,9 +5696,10 @@ const deserializeAws_json1_1DeviceCgroupPermissions = (output, context) => {
7245
5696
  }
7246
5697
  return smithy_client_1.expectString(entry);
7247
5698
  });
5699
+ return retVal;
7248
5700
  };
7249
5701
  const deserializeAws_json1_1DevicesList = (output, context) => {
7250
- return (output || [])
5702
+ const retVal = (output || [])
7251
5703
  .filter((e) => e != null)
7252
5704
  .map((entry) => {
7253
5705
  if (entry === null) {
@@ -7255,6 +5707,7 @@ const deserializeAws_json1_1DevicesList = (output, context) => {
7255
5707
  }
7256
5708
  return deserializeAws_json1_1Device(entry, context);
7257
5709
  });
5710
+ return retVal;
7258
5711
  };
7259
5712
  const deserializeAws_json1_1DiscoverPollEndpointResponse = (output, context) => {
7260
5713
  return {
@@ -7310,7 +5763,7 @@ const deserializeAws_json1_1EnvironmentFile = (output, context) => {
7310
5763
  };
7311
5764
  };
7312
5765
  const deserializeAws_json1_1EnvironmentFiles = (output, context) => {
7313
- return (output || [])
5766
+ const retVal = (output || [])
7314
5767
  .filter((e) => e != null)
7315
5768
  .map((entry) => {
7316
5769
  if (entry === null) {
@@ -7318,9 +5771,10 @@ const deserializeAws_json1_1EnvironmentFiles = (output, context) => {
7318
5771
  }
7319
5772
  return deserializeAws_json1_1EnvironmentFile(entry, context);
7320
5773
  });
5774
+ return retVal;
7321
5775
  };
7322
5776
  const deserializeAws_json1_1EnvironmentVariables = (output, context) => {
7323
- return (output || [])
5777
+ const retVal = (output || [])
7324
5778
  .filter((e) => e != null)
7325
5779
  .map((entry) => {
7326
5780
  if (entry === null) {
@@ -7328,6 +5782,7 @@ const deserializeAws_json1_1EnvironmentVariables = (output, context) => {
7328
5782
  }
7329
5783
  return deserializeAws_json1_1KeyValuePair(entry, context);
7330
5784
  });
5785
+ return retVal;
7331
5786
  };
7332
5787
  const deserializeAws_json1_1EphemeralStorage = (output, context) => {
7333
5788
  return {
@@ -7372,7 +5827,7 @@ const deserializeAws_json1_1Failure = (output, context) => {
7372
5827
  };
7373
5828
  };
7374
5829
  const deserializeAws_json1_1Failures = (output, context) => {
7375
- return (output || [])
5830
+ const retVal = (output || [])
7376
5831
  .filter((e) => e != null)
7377
5832
  .map((entry) => {
7378
5833
  if (entry === null) {
@@ -7380,6 +5835,7 @@ const deserializeAws_json1_1Failures = (output, context) => {
7380
5835
  }
7381
5836
  return deserializeAws_json1_1Failure(entry, context);
7382
5837
  });
5838
+ return retVal;
7383
5839
  };
7384
5840
  const deserializeAws_json1_1FirelensConfiguration = (output, context) => {
7385
5841
  return {
@@ -7416,7 +5872,7 @@ const deserializeAws_json1_1FSxWindowsFileServerVolumeConfiguration = (output, c
7416
5872
  };
7417
5873
  };
7418
5874
  const deserializeAws_json1_1GpuIds = (output, context) => {
7419
- return (output || [])
5875
+ const retVal = (output || [])
7420
5876
  .filter((e) => e != null)
7421
5877
  .map((entry) => {
7422
5878
  if (entry === null) {
@@ -7424,6 +5880,7 @@ const deserializeAws_json1_1GpuIds = (output, context) => {
7424
5880
  }
7425
5881
  return smithy_client_1.expectString(entry);
7426
5882
  });
5883
+ return retVal;
7427
5884
  };
7428
5885
  const deserializeAws_json1_1HealthCheck = (output, context) => {
7429
5886
  return {
@@ -7443,7 +5900,7 @@ const deserializeAws_json1_1HostEntry = (output, context) => {
7443
5900
  };
7444
5901
  };
7445
5902
  const deserializeAws_json1_1HostEntryList = (output, context) => {
7446
- return (output || [])
5903
+ const retVal = (output || [])
7447
5904
  .filter((e) => e != null)
7448
5905
  .map((entry) => {
7449
5906
  if (entry === null) {
@@ -7451,6 +5908,7 @@ const deserializeAws_json1_1HostEntryList = (output, context) => {
7451
5908
  }
7452
5909
  return deserializeAws_json1_1HostEntry(entry, context);
7453
5910
  });
5911
+ return retVal;
7454
5912
  };
7455
5913
  const deserializeAws_json1_1HostVolumeProperties = (output, context) => {
7456
5914
  return {
@@ -7470,7 +5928,7 @@ const deserializeAws_json1_1InferenceAcceleratorOverride = (output, context) =>
7470
5928
  };
7471
5929
  };
7472
5930
  const deserializeAws_json1_1InferenceAcceleratorOverrides = (output, context) => {
7473
- return (output || [])
5931
+ const retVal = (output || [])
7474
5932
  .filter((e) => e != null)
7475
5933
  .map((entry) => {
7476
5934
  if (entry === null) {
@@ -7478,9 +5936,10 @@ const deserializeAws_json1_1InferenceAcceleratorOverrides = (output, context) =>
7478
5936
  }
7479
5937
  return deserializeAws_json1_1InferenceAcceleratorOverride(entry, context);
7480
5938
  });
5939
+ return retVal;
7481
5940
  };
7482
5941
  const deserializeAws_json1_1InferenceAccelerators = (output, context) => {
7483
- return (output || [])
5942
+ const retVal = (output || [])
7484
5943
  .filter((e) => e != null)
7485
5944
  .map((entry) => {
7486
5945
  if (entry === null) {
@@ -7488,6 +5947,7 @@ const deserializeAws_json1_1InferenceAccelerators = (output, context) => {
7488
5947
  }
7489
5948
  return deserializeAws_json1_1InferenceAccelerator(entry, context);
7490
5949
  });
5950
+ return retVal;
7491
5951
  };
7492
5952
  const deserializeAws_json1_1InstanceHealthCheckResult = (output, context) => {
7493
5953
  return {
@@ -7502,7 +5962,7 @@ const deserializeAws_json1_1InstanceHealthCheckResult = (output, context) => {
7502
5962
  };
7503
5963
  };
7504
5964
  const deserializeAws_json1_1InstanceHealthCheckResultList = (output, context) => {
7505
- return (output || [])
5965
+ const retVal = (output || [])
7506
5966
  .filter((e) => e != null)
7507
5967
  .map((entry) => {
7508
5968
  if (entry === null) {
@@ -7510,6 +5970,7 @@ const deserializeAws_json1_1InstanceHealthCheckResultList = (output, context) =>
7510
5970
  }
7511
5971
  return deserializeAws_json1_1InstanceHealthCheckResult(entry, context);
7512
5972
  });
5973
+ return retVal;
7513
5974
  };
7514
5975
  const deserializeAws_json1_1InvalidParameterException = (output, context) => {
7515
5976
  return {
@@ -7632,7 +6093,7 @@ const deserializeAws_json1_1LoadBalancer = (output, context) => {
7632
6093
  };
7633
6094
  };
7634
6095
  const deserializeAws_json1_1LoadBalancers = (output, context) => {
7635
- return (output || [])
6096
+ const retVal = (output || [])
7636
6097
  .filter((e) => e != null)
7637
6098
  .map((entry) => {
7638
6099
  if (entry === null) {
@@ -7640,6 +6101,7 @@ const deserializeAws_json1_1LoadBalancers = (output, context) => {
7640
6101
  }
7641
6102
  return deserializeAws_json1_1LoadBalancer(entry, context);
7642
6103
  });
6104
+ return retVal;
7643
6105
  };
7644
6106
  const deserializeAws_json1_1LogConfiguration = (output, context) => {
7645
6107
  return {
@@ -7674,7 +6136,7 @@ const deserializeAws_json1_1ManagedAgent = (output, context) => {
7674
6136
  };
7675
6137
  };
7676
6138
  const deserializeAws_json1_1ManagedAgents = (output, context) => {
7677
- return (output || [])
6139
+ const retVal = (output || [])
7678
6140
  .filter((e) => e != null)
7679
6141
  .map((entry) => {
7680
6142
  if (entry === null) {
@@ -7682,6 +6144,7 @@ const deserializeAws_json1_1ManagedAgents = (output, context) => {
7682
6144
  }
7683
6145
  return deserializeAws_json1_1ManagedAgent(entry, context);
7684
6146
  });
6147
+ return retVal;
7685
6148
  };
7686
6149
  const deserializeAws_json1_1ManagedScaling = (output, context) => {
7687
6150
  return {
@@ -7705,7 +6168,7 @@ const deserializeAws_json1_1MountPoint = (output, context) => {
7705
6168
  };
7706
6169
  };
7707
6170
  const deserializeAws_json1_1MountPointList = (output, context) => {
7708
- return (output || [])
6171
+ const retVal = (output || [])
7709
6172
  .filter((e) => e != null)
7710
6173
  .map((entry) => {
7711
6174
  if (entry === null) {
@@ -7713,6 +6176,7 @@ const deserializeAws_json1_1MountPointList = (output, context) => {
7713
6176
  }
7714
6177
  return deserializeAws_json1_1MountPoint(entry, context);
7715
6178
  });
6179
+ return retVal;
7716
6180
  };
7717
6181
  const deserializeAws_json1_1NetworkBinding = (output, context) => {
7718
6182
  return {
@@ -7723,7 +6187,7 @@ const deserializeAws_json1_1NetworkBinding = (output, context) => {
7723
6187
  };
7724
6188
  };
7725
6189
  const deserializeAws_json1_1NetworkBindings = (output, context) => {
7726
- return (output || [])
6190
+ const retVal = (output || [])
7727
6191
  .filter((e) => e != null)
7728
6192
  .map((entry) => {
7729
6193
  if (entry === null) {
@@ -7731,6 +6195,7 @@ const deserializeAws_json1_1NetworkBindings = (output, context) => {
7731
6195
  }
7732
6196
  return deserializeAws_json1_1NetworkBinding(entry, context);
7733
6197
  });
6198
+ return retVal;
7734
6199
  };
7735
6200
  const deserializeAws_json1_1NetworkConfiguration = (output, context) => {
7736
6201
  return {
@@ -7747,7 +6212,7 @@ const deserializeAws_json1_1NetworkInterface = (output, context) => {
7747
6212
  };
7748
6213
  };
7749
6214
  const deserializeAws_json1_1NetworkInterfaces = (output, context) => {
7750
- return (output || [])
6215
+ const retVal = (output || [])
7751
6216
  .filter((e) => e != null)
7752
6217
  .map((entry) => {
7753
6218
  if (entry === null) {
@@ -7755,6 +6220,7 @@ const deserializeAws_json1_1NetworkInterfaces = (output, context) => {
7755
6220
  }
7756
6221
  return deserializeAws_json1_1NetworkInterface(entry, context);
7757
6222
  });
6223
+ return retVal;
7758
6224
  };
7759
6225
  const deserializeAws_json1_1NoUpdateAvailableException = (output, context) => {
7760
6226
  return {
@@ -7768,7 +6234,7 @@ const deserializeAws_json1_1PlacementConstraint = (output, context) => {
7768
6234
  };
7769
6235
  };
7770
6236
  const deserializeAws_json1_1PlacementConstraints = (output, context) => {
7771
- return (output || [])
6237
+ const retVal = (output || [])
7772
6238
  .filter((e) => e != null)
7773
6239
  .map((entry) => {
7774
6240
  if (entry === null) {
@@ -7776,9 +6242,10 @@ const deserializeAws_json1_1PlacementConstraints = (output, context) => {
7776
6242
  }
7777
6243
  return deserializeAws_json1_1PlacementConstraint(entry, context);
7778
6244
  });
6245
+ return retVal;
7779
6246
  };
7780
6247
  const deserializeAws_json1_1PlacementStrategies = (output, context) => {
7781
- return (output || [])
6248
+ const retVal = (output || [])
7782
6249
  .filter((e) => e != null)
7783
6250
  .map((entry) => {
7784
6251
  if (entry === null) {
@@ -7786,6 +6253,7 @@ const deserializeAws_json1_1PlacementStrategies = (output, context) => {
7786
6253
  }
7787
6254
  return deserializeAws_json1_1PlacementStrategy(entry, context);
7788
6255
  });
6256
+ return retVal;
7789
6257
  };
7790
6258
  const deserializeAws_json1_1PlacementStrategy = (output, context) => {
7791
6259
  return {
@@ -7811,7 +6279,7 @@ const deserializeAws_json1_1PortMapping = (output, context) => {
7811
6279
  };
7812
6280
  };
7813
6281
  const deserializeAws_json1_1PortMappingList = (output, context) => {
7814
- return (output || [])
6282
+ const retVal = (output || [])
7815
6283
  .filter((e) => e != null)
7816
6284
  .map((entry) => {
7817
6285
  if (entry === null) {
@@ -7819,6 +6287,7 @@ const deserializeAws_json1_1PortMappingList = (output, context) => {
7819
6287
  }
7820
6288
  return deserializeAws_json1_1PortMapping(entry, context);
7821
6289
  });
6290
+ return retVal;
7822
6291
  };
7823
6292
  const deserializeAws_json1_1ProxyConfiguration = (output, context) => {
7824
6293
  return {
@@ -7830,7 +6299,7 @@ const deserializeAws_json1_1ProxyConfiguration = (output, context) => {
7830
6299
  };
7831
6300
  };
7832
6301
  const deserializeAws_json1_1ProxyConfigurationProperties = (output, context) => {
7833
- return (output || [])
6302
+ const retVal = (output || [])
7834
6303
  .filter((e) => e != null)
7835
6304
  .map((entry) => {
7836
6305
  if (entry === null) {
@@ -7838,6 +6307,7 @@ const deserializeAws_json1_1ProxyConfigurationProperties = (output, context) =>
7838
6307
  }
7839
6308
  return deserializeAws_json1_1KeyValuePair(entry, context);
7840
6309
  });
6310
+ return retVal;
7841
6311
  };
7842
6312
  const deserializeAws_json1_1PutAccountSettingDefaultResponse = (output, context) => {
7843
6313
  return {
@@ -7888,7 +6358,7 @@ const deserializeAws_json1_1RepositoryCredentials = (output, context) => {
7888
6358
  };
7889
6359
  };
7890
6360
  const deserializeAws_json1_1RequiresAttributes = (output, context) => {
7891
- return (output || [])
6361
+ const retVal = (output || [])
7892
6362
  .filter((e) => e != null)
7893
6363
  .map((entry) => {
7894
6364
  if (entry === null) {
@@ -7896,6 +6366,7 @@ const deserializeAws_json1_1RequiresAttributes = (output, context) => {
7896
6366
  }
7897
6367
  return deserializeAws_json1_1Attribute(entry, context);
7898
6368
  });
6369
+ return retVal;
7899
6370
  };
7900
6371
  const deserializeAws_json1_1Resource = (output, context) => {
7901
6372
  return {
@@ -7926,7 +6397,7 @@ const deserializeAws_json1_1ResourceRequirement = (output, context) => {
7926
6397
  };
7927
6398
  };
7928
6399
  const deserializeAws_json1_1ResourceRequirements = (output, context) => {
7929
- return (output || [])
6400
+ const retVal = (output || [])
7930
6401
  .filter((e) => e != null)
7931
6402
  .map((entry) => {
7932
6403
  if (entry === null) {
@@ -7934,9 +6405,10 @@ const deserializeAws_json1_1ResourceRequirements = (output, context) => {
7934
6405
  }
7935
6406
  return deserializeAws_json1_1ResourceRequirement(entry, context);
7936
6407
  });
6408
+ return retVal;
7937
6409
  };
7938
6410
  const deserializeAws_json1_1Resources = (output, context) => {
7939
- return (output || [])
6411
+ const retVal = (output || [])
7940
6412
  .filter((e) => e != null)
7941
6413
  .map((entry) => {
7942
6414
  if (entry === null) {
@@ -7944,6 +6416,7 @@ const deserializeAws_json1_1Resources = (output, context) => {
7944
6416
  }
7945
6417
  return deserializeAws_json1_1Resource(entry, context);
7946
6418
  });
6419
+ return retVal;
7947
6420
  };
7948
6421
  const deserializeAws_json1_1RunTaskResponse = (output, context) => {
7949
6422
  return {
@@ -7974,7 +6447,7 @@ const deserializeAws_json1_1Secret = (output, context) => {
7974
6447
  };
7975
6448
  };
7976
6449
  const deserializeAws_json1_1SecretList = (output, context) => {
7977
- return (output || [])
6450
+ const retVal = (output || [])
7978
6451
  .filter((e) => e != null)
7979
6452
  .map((entry) => {
7980
6453
  if (entry === null) {
@@ -7982,6 +6455,7 @@ const deserializeAws_json1_1SecretList = (output, context) => {
7982
6455
  }
7983
6456
  return deserializeAws_json1_1Secret(entry, context);
7984
6457
  });
6458
+ return retVal;
7985
6459
  };
7986
6460
  const deserializeAws_json1_1ServerException = (output, context) => {
7987
6461
  return {
@@ -8057,7 +6531,7 @@ const deserializeAws_json1_1ServiceEvent = (output, context) => {
8057
6531
  };
8058
6532
  };
8059
6533
  const deserializeAws_json1_1ServiceEvents = (output, context) => {
8060
- return (output || [])
6534
+ const retVal = (output || [])
8061
6535
  .filter((e) => e != null)
8062
6536
  .map((entry) => {
8063
6537
  if (entry === null) {
@@ -8065,6 +6539,7 @@ const deserializeAws_json1_1ServiceEvents = (output, context) => {
8065
6539
  }
8066
6540
  return deserializeAws_json1_1ServiceEvent(entry, context);
8067
6541
  });
6542
+ return retVal;
8068
6543
  };
8069
6544
  const deserializeAws_json1_1ServiceNotActiveException = (output, context) => {
8070
6545
  return {
@@ -8077,7 +6552,7 @@ const deserializeAws_json1_1ServiceNotFoundException = (output, context) => {
8077
6552
  };
8078
6553
  };
8079
6554
  const deserializeAws_json1_1ServiceRegistries = (output, context) => {
8080
- return (output || [])
6555
+ const retVal = (output || [])
8081
6556
  .filter((e) => e != null)
8082
6557
  .map((entry) => {
8083
6558
  if (entry === null) {
@@ -8085,6 +6560,7 @@ const deserializeAws_json1_1ServiceRegistries = (output, context) => {
8085
6560
  }
8086
6561
  return deserializeAws_json1_1ServiceRegistry(entry, context);
8087
6562
  });
6563
+ return retVal;
8088
6564
  };
8089
6565
  const deserializeAws_json1_1ServiceRegistry = (output, context) => {
8090
6566
  return {
@@ -8095,7 +6571,7 @@ const deserializeAws_json1_1ServiceRegistry = (output, context) => {
8095
6571
  };
8096
6572
  };
8097
6573
  const deserializeAws_json1_1Services = (output, context) => {
8098
- return (output || [])
6574
+ const retVal = (output || [])
8099
6575
  .filter((e) => e != null)
8100
6576
  .map((entry) => {
8101
6577
  if (entry === null) {
@@ -8103,6 +6579,7 @@ const deserializeAws_json1_1Services = (output, context) => {
8103
6579
  }
8104
6580
  return deserializeAws_json1_1Service(entry, context);
8105
6581
  });
6582
+ return retVal;
8106
6583
  };
8107
6584
  const deserializeAws_json1_1Session = (output, context) => {
8108
6585
  return {
@@ -8119,7 +6596,7 @@ const deserializeAws_json1_1Setting = (output, context) => {
8119
6596
  };
8120
6597
  };
8121
6598
  const deserializeAws_json1_1Settings = (output, context) => {
8122
- return (output || [])
6599
+ const retVal = (output || [])
8123
6600
  .filter((e) => e != null)
8124
6601
  .map((entry) => {
8125
6602
  if (entry === null) {
@@ -8127,6 +6604,7 @@ const deserializeAws_json1_1Settings = (output, context) => {
8127
6604
  }
8128
6605
  return deserializeAws_json1_1Setting(entry, context);
8129
6606
  });
6607
+ return retVal;
8130
6608
  };
8131
6609
  const deserializeAws_json1_1StartTaskResponse = (output, context) => {
8132
6610
  return {
@@ -8139,7 +6617,7 @@ const deserializeAws_json1_1StartTaskResponse = (output, context) => {
8139
6617
  };
8140
6618
  };
8141
6619
  const deserializeAws_json1_1Statistics = (output, context) => {
8142
- return (output || [])
6620
+ const retVal = (output || [])
8143
6621
  .filter((e) => e != null)
8144
6622
  .map((entry) => {
8145
6623
  if (entry === null) {
@@ -8147,6 +6625,7 @@ const deserializeAws_json1_1Statistics = (output, context) => {
8147
6625
  }
8148
6626
  return deserializeAws_json1_1KeyValuePair(entry, context);
8149
6627
  });
6628
+ return retVal;
8150
6629
  };
8151
6630
  const deserializeAws_json1_1StopTaskResponse = (output, context) => {
8152
6631
  return {
@@ -8154,7 +6633,7 @@ const deserializeAws_json1_1StopTaskResponse = (output, context) => {
8154
6633
  };
8155
6634
  };
8156
6635
  const deserializeAws_json1_1StringList = (output, context) => {
8157
- return (output || [])
6636
+ const retVal = (output || [])
8158
6637
  .filter((e) => e != null)
8159
6638
  .map((entry) => {
8160
6639
  if (entry === null) {
@@ -8162,6 +6641,7 @@ const deserializeAws_json1_1StringList = (output, context) => {
8162
6641
  }
8163
6642
  return smithy_client_1.expectString(entry);
8164
6643
  });
6644
+ return retVal;
8165
6645
  };
8166
6646
  const deserializeAws_json1_1StringMap = (output, context) => {
8167
6647
  return Object.entries(output).reduce((acc, [key, value]) => {
@@ -8196,7 +6676,7 @@ const deserializeAws_json1_1SystemControl = (output, context) => {
8196
6676
  };
8197
6677
  };
8198
6678
  const deserializeAws_json1_1SystemControls = (output, context) => {
8199
- return (output || [])
6679
+ const retVal = (output || [])
8200
6680
  .filter((e) => e != null)
8201
6681
  .map((entry) => {
8202
6682
  if (entry === null) {
@@ -8204,6 +6684,7 @@ const deserializeAws_json1_1SystemControls = (output, context) => {
8204
6684
  }
8205
6685
  return deserializeAws_json1_1SystemControl(entry, context);
8206
6686
  });
6687
+ return retVal;
8207
6688
  };
8208
6689
  const deserializeAws_json1_1Tag = (output, context) => {
8209
6690
  return {
@@ -8215,7 +6696,7 @@ const deserializeAws_json1_1TagResourceResponse = (output, context) => {
8215
6696
  return {};
8216
6697
  };
8217
6698
  const deserializeAws_json1_1Tags = (output, context) => {
8218
- return (output || [])
6699
+ const retVal = (output || [])
8219
6700
  .filter((e) => e != null)
8220
6701
  .map((entry) => {
8221
6702
  if (entry === null) {
@@ -8223,6 +6704,7 @@ const deserializeAws_json1_1Tags = (output, context) => {
8223
6704
  }
8224
6705
  return deserializeAws_json1_1Tag(entry, context);
8225
6706
  });
6707
+ return retVal;
8226
6708
  };
8227
6709
  const deserializeAws_json1_1TargetNotConnectedException = (output, context) => {
8228
6710
  return {
@@ -8361,7 +6843,7 @@ const deserializeAws_json1_1TaskDefinitionPlacementConstraint = (output, context
8361
6843
  };
8362
6844
  };
8363
6845
  const deserializeAws_json1_1TaskDefinitionPlacementConstraints = (output, context) => {
8364
- return (output || [])
6846
+ const retVal = (output || [])
8365
6847
  .filter((e) => e != null)
8366
6848
  .map((entry) => {
8367
6849
  if (entry === null) {
@@ -8369,6 +6851,7 @@ const deserializeAws_json1_1TaskDefinitionPlacementConstraints = (output, contex
8369
6851
  }
8370
6852
  return deserializeAws_json1_1TaskDefinitionPlacementConstraint(entry, context);
8371
6853
  });
6854
+ return retVal;
8372
6855
  };
8373
6856
  const deserializeAws_json1_1TaskOverride = (output, context) => {
8374
6857
  return {
@@ -8388,7 +6871,7 @@ const deserializeAws_json1_1TaskOverride = (output, context) => {
8388
6871
  };
8389
6872
  };
8390
6873
  const deserializeAws_json1_1Tasks = (output, context) => {
8391
- return (output || [])
6874
+ const retVal = (output || [])
8392
6875
  .filter((e) => e != null)
8393
6876
  .map((entry) => {
8394
6877
  if (entry === null) {
@@ -8396,6 +6879,7 @@ const deserializeAws_json1_1Tasks = (output, context) => {
8396
6879
  }
8397
6880
  return deserializeAws_json1_1Task(entry, context);
8398
6881
  });
6882
+ return retVal;
8399
6883
  };
8400
6884
  const deserializeAws_json1_1TaskSet = (output, context) => {
8401
6885
  return {
@@ -8447,7 +6931,7 @@ const deserializeAws_json1_1TaskSetNotFoundException = (output, context) => {
8447
6931
  };
8448
6932
  };
8449
6933
  const deserializeAws_json1_1TaskSets = (output, context) => {
8450
- return (output || [])
6934
+ const retVal = (output || [])
8451
6935
  .filter((e) => e != null)
8452
6936
  .map((entry) => {
8453
6937
  if (entry === null) {
@@ -8455,6 +6939,7 @@ const deserializeAws_json1_1TaskSets = (output, context) => {
8455
6939
  }
8456
6940
  return deserializeAws_json1_1TaskSet(entry, context);
8457
6941
  });
6942
+ return retVal;
8458
6943
  };
8459
6944
  const deserializeAws_json1_1Tmpfs = (output, context) => {
8460
6945
  return {
@@ -8466,7 +6951,7 @@ const deserializeAws_json1_1Tmpfs = (output, context) => {
8466
6951
  };
8467
6952
  };
8468
6953
  const deserializeAws_json1_1TmpfsList = (output, context) => {
8469
- return (output || [])
6954
+ const retVal = (output || [])
8470
6955
  .filter((e) => e != null)
8471
6956
  .map((entry) => {
8472
6957
  if (entry === null) {
@@ -8474,6 +6959,7 @@ const deserializeAws_json1_1TmpfsList = (output, context) => {
8474
6959
  }
8475
6960
  return deserializeAws_json1_1Tmpfs(entry, context);
8476
6961
  });
6962
+ return retVal;
8477
6963
  };
8478
6964
  const deserializeAws_json1_1Ulimit = (output, context) => {
8479
6965
  return {
@@ -8483,7 +6969,7 @@ const deserializeAws_json1_1Ulimit = (output, context) => {
8483
6969
  };
8484
6970
  };
8485
6971
  const deserializeAws_json1_1UlimitList = (output, context) => {
8486
- return (output || [])
6972
+ const retVal = (output || [])
8487
6973
  .filter((e) => e != null)
8488
6974
  .map((entry) => {
8489
6975
  if (entry === null) {
@@ -8491,6 +6977,7 @@ const deserializeAws_json1_1UlimitList = (output, context) => {
8491
6977
  }
8492
6978
  return deserializeAws_json1_1Ulimit(entry, context);
8493
6979
  });
6980
+ return retVal;
8494
6981
  };
8495
6982
  const deserializeAws_json1_1UnsupportedFeatureException = (output, context) => {
8496
6983
  return {
@@ -8596,7 +7083,7 @@ const deserializeAws_json1_1VolumeFrom = (output, context) => {
8596
7083
  };
8597
7084
  };
8598
7085
  const deserializeAws_json1_1VolumeFromList = (output, context) => {
8599
- return (output || [])
7086
+ const retVal = (output || [])
8600
7087
  .filter((e) => e != null)
8601
7088
  .map((entry) => {
8602
7089
  if (entry === null) {
@@ -8604,9 +7091,10 @@ const deserializeAws_json1_1VolumeFromList = (output, context) => {
8604
7091
  }
8605
7092
  return deserializeAws_json1_1VolumeFrom(entry, context);
8606
7093
  });
7094
+ return retVal;
8607
7095
  };
8608
7096
  const deserializeAws_json1_1VolumeList = (output, context) => {
8609
- return (output || [])
7097
+ const retVal = (output || [])
8610
7098
  .filter((e) => e != null)
8611
7099
  .map((entry) => {
8612
7100
  if (entry === null) {
@@ -8614,6 +7102,7 @@ const deserializeAws_json1_1VolumeList = (output, context) => {
8614
7102
  }
8615
7103
  return deserializeAws_json1_1Volume(entry, context);
8616
7104
  });
7105
+ return retVal;
8617
7106
  };
8618
7107
  const deserializeMetadata = (output) => {
8619
7108
  var _a;