@aws-sdk/client-emr 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.
- package/CHANGELOG.md +11 -0
- package/dist-cjs/index.js +3 -0
- package/dist-cjs/models/EMRServiceException.js +11 -0
- package/dist-cjs/models/models_0.js +48 -5
- package/dist-cjs/protocols/Aws_json1_1.js +369 -1050
- package/dist-es/index.js +1 -0
- package/dist-es/models/EMRServiceException.js +12 -0
- package/dist-es/models/models_0.js +41 -1
- package/dist-es/protocols/Aws_json1_1.js +834 -1197
- package/dist-types/index.d.ts +1 -0
- package/dist-types/models/EMRServiceException.d.ts +10 -0
- package/dist-types/models/models_0.d.ts +23 -10
- package/dist-types/ts3.4/index.d.ts +1 -0
- package/dist-types/ts3.4/models/EMRServiceException.d.ts +6 -0
- package/dist-types/ts3.4/models/models_0.d.ts +17 -10
- package/package.json +26 -26
|
@@ -5,6 +5,8 @@ exports.deserializeAws_json1_1StartNotebookExecutionCommand = exports.deserializ
|
|
|
5
5
|
exports.deserializeAws_json1_1UpdateStudioSessionMappingCommand = exports.deserializeAws_json1_1UpdateStudioCommand = exports.deserializeAws_json1_1TerminateJobFlowsCommand = exports.deserializeAws_json1_1StopNotebookExecutionCommand = 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 EMRServiceException_1 = require("../models/EMRServiceException");
|
|
9
|
+
const models_0_1 = require("../models/models_0");
|
|
8
10
|
const serializeAws_json1_1AddInstanceFleetCommand = async (input, context) => {
|
|
9
11
|
const headers = {
|
|
10
12
|
"content-type": "application/x-amz-json-1.1",
|
|
@@ -550,35 +552,19 @@ const deserializeAws_json1_1AddInstanceFleetCommandError = async (output, contex
|
|
|
550
552
|
switch (errorCode) {
|
|
551
553
|
case "InternalServerException":
|
|
552
554
|
case "com.amazonaws.emr#InternalServerException":
|
|
553
|
-
|
|
554
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
555
|
-
name: errorCode,
|
|
556
|
-
$metadata: deserializeMetadata(output),
|
|
557
|
-
};
|
|
558
|
-
break;
|
|
555
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
559
556
|
case "InvalidRequestException":
|
|
560
557
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
561
|
-
|
|
562
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
563
|
-
name: errorCode,
|
|
564
|
-
$metadata: deserializeMetadata(output),
|
|
565
|
-
};
|
|
566
|
-
break;
|
|
558
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
567
559
|
default:
|
|
568
560
|
const parsedBody = parsedOutput.body;
|
|
569
|
-
|
|
570
|
-
|
|
571
|
-
...parsedBody,
|
|
572
|
-
name: `${errorCode}`,
|
|
573
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
561
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
562
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
574
563
|
$fault: "client",
|
|
575
564
|
$metadata: deserializeMetadata(output),
|
|
576
|
-
};
|
|
565
|
+
});
|
|
566
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
577
567
|
}
|
|
578
|
-
const message = response.message || response.Message || errorCode;
|
|
579
|
-
response.message = message;
|
|
580
|
-
delete response.Message;
|
|
581
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
582
568
|
};
|
|
583
569
|
const deserializeAws_json1_1AddInstanceGroupsCommand = async (output, context) => {
|
|
584
570
|
if (output.statusCode >= 300) {
|
|
@@ -605,27 +591,16 @@ const deserializeAws_json1_1AddInstanceGroupsCommandError = async (output, conte
|
|
|
605
591
|
switch (errorCode) {
|
|
606
592
|
case "InternalServerError":
|
|
607
593
|
case "com.amazonaws.emr#InternalServerError":
|
|
608
|
-
|
|
609
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
610
|
-
name: errorCode,
|
|
611
|
-
$metadata: deserializeMetadata(output),
|
|
612
|
-
};
|
|
613
|
-
break;
|
|
594
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
614
595
|
default:
|
|
615
596
|
const parsedBody = parsedOutput.body;
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
...parsedBody,
|
|
619
|
-
name: `${errorCode}`,
|
|
620
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
597
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
598
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
621
599
|
$fault: "client",
|
|
622
600
|
$metadata: deserializeMetadata(output),
|
|
623
|
-
};
|
|
601
|
+
});
|
|
602
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
624
603
|
}
|
|
625
|
-
const message = response.message || response.Message || errorCode;
|
|
626
|
-
response.message = message;
|
|
627
|
-
delete response.Message;
|
|
628
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
629
604
|
};
|
|
630
605
|
const deserializeAws_json1_1AddJobFlowStepsCommand = async (output, context) => {
|
|
631
606
|
if (output.statusCode >= 300) {
|
|
@@ -652,27 +627,16 @@ const deserializeAws_json1_1AddJobFlowStepsCommandError = async (output, context
|
|
|
652
627
|
switch (errorCode) {
|
|
653
628
|
case "InternalServerError":
|
|
654
629
|
case "com.amazonaws.emr#InternalServerError":
|
|
655
|
-
|
|
656
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
657
|
-
name: errorCode,
|
|
658
|
-
$metadata: deserializeMetadata(output),
|
|
659
|
-
};
|
|
660
|
-
break;
|
|
630
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
661
631
|
default:
|
|
662
632
|
const parsedBody = parsedOutput.body;
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
...parsedBody,
|
|
666
|
-
name: `${errorCode}`,
|
|
667
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
633
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
634
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
668
635
|
$fault: "client",
|
|
669
636
|
$metadata: deserializeMetadata(output),
|
|
670
|
-
};
|
|
637
|
+
});
|
|
638
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
671
639
|
}
|
|
672
|
-
const message = response.message || response.Message || errorCode;
|
|
673
|
-
response.message = message;
|
|
674
|
-
delete response.Message;
|
|
675
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
676
640
|
};
|
|
677
641
|
const deserializeAws_json1_1AddTagsCommand = async (output, context) => {
|
|
678
642
|
if (output.statusCode >= 300) {
|
|
@@ -699,35 +663,19 @@ const deserializeAws_json1_1AddTagsCommandError = async (output, context) => {
|
|
|
699
663
|
switch (errorCode) {
|
|
700
664
|
case "InternalServerException":
|
|
701
665
|
case "com.amazonaws.emr#InternalServerException":
|
|
702
|
-
|
|
703
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
704
|
-
name: errorCode,
|
|
705
|
-
$metadata: deserializeMetadata(output),
|
|
706
|
-
};
|
|
707
|
-
break;
|
|
666
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
708
667
|
case "InvalidRequestException":
|
|
709
668
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
710
|
-
|
|
711
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
712
|
-
name: errorCode,
|
|
713
|
-
$metadata: deserializeMetadata(output),
|
|
714
|
-
};
|
|
715
|
-
break;
|
|
669
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
716
670
|
default:
|
|
717
671
|
const parsedBody = parsedOutput.body;
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
...parsedBody,
|
|
721
|
-
name: `${errorCode}`,
|
|
722
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
672
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
673
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
723
674
|
$fault: "client",
|
|
724
675
|
$metadata: deserializeMetadata(output),
|
|
725
|
-
};
|
|
676
|
+
});
|
|
677
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
726
678
|
}
|
|
727
|
-
const message = response.message || response.Message || errorCode;
|
|
728
|
-
response.message = message;
|
|
729
|
-
delete response.Message;
|
|
730
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
731
679
|
};
|
|
732
680
|
const deserializeAws_json1_1CancelStepsCommand = async (output, context) => {
|
|
733
681
|
if (output.statusCode >= 300) {
|
|
@@ -754,35 +702,19 @@ const deserializeAws_json1_1CancelStepsCommandError = async (output, context) =>
|
|
|
754
702
|
switch (errorCode) {
|
|
755
703
|
case "InternalServerError":
|
|
756
704
|
case "com.amazonaws.emr#InternalServerError":
|
|
757
|
-
|
|
758
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
759
|
-
name: errorCode,
|
|
760
|
-
$metadata: deserializeMetadata(output),
|
|
761
|
-
};
|
|
762
|
-
break;
|
|
705
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
763
706
|
case "InvalidRequestException":
|
|
764
707
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
765
|
-
|
|
766
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
767
|
-
name: errorCode,
|
|
768
|
-
$metadata: deserializeMetadata(output),
|
|
769
|
-
};
|
|
770
|
-
break;
|
|
708
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
771
709
|
default:
|
|
772
710
|
const parsedBody = parsedOutput.body;
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
...parsedBody,
|
|
776
|
-
name: `${errorCode}`,
|
|
777
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
711
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
712
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
778
713
|
$fault: "client",
|
|
779
714
|
$metadata: deserializeMetadata(output),
|
|
780
|
-
};
|
|
715
|
+
});
|
|
716
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
781
717
|
}
|
|
782
|
-
const message = response.message || response.Message || errorCode;
|
|
783
|
-
response.message = message;
|
|
784
|
-
delete response.Message;
|
|
785
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
786
718
|
};
|
|
787
719
|
const deserializeAws_json1_1CreateSecurityConfigurationCommand = async (output, context) => {
|
|
788
720
|
if (output.statusCode >= 300) {
|
|
@@ -809,35 +741,19 @@ const deserializeAws_json1_1CreateSecurityConfigurationCommandError = async (out
|
|
|
809
741
|
switch (errorCode) {
|
|
810
742
|
case "InternalServerException":
|
|
811
743
|
case "com.amazonaws.emr#InternalServerException":
|
|
812
|
-
|
|
813
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
814
|
-
name: errorCode,
|
|
815
|
-
$metadata: deserializeMetadata(output),
|
|
816
|
-
};
|
|
817
|
-
break;
|
|
744
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
818
745
|
case "InvalidRequestException":
|
|
819
746
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
820
|
-
|
|
821
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
822
|
-
name: errorCode,
|
|
823
|
-
$metadata: deserializeMetadata(output),
|
|
824
|
-
};
|
|
825
|
-
break;
|
|
747
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
826
748
|
default:
|
|
827
749
|
const parsedBody = parsedOutput.body;
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
...parsedBody,
|
|
831
|
-
name: `${errorCode}`,
|
|
832
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
750
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
751
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
833
752
|
$fault: "client",
|
|
834
753
|
$metadata: deserializeMetadata(output),
|
|
835
|
-
};
|
|
754
|
+
});
|
|
755
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
836
756
|
}
|
|
837
|
-
const message = response.message || response.Message || errorCode;
|
|
838
|
-
response.message = message;
|
|
839
|
-
delete response.Message;
|
|
840
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
841
757
|
};
|
|
842
758
|
const deserializeAws_json1_1CreateStudioCommand = async (output, context) => {
|
|
843
759
|
if (output.statusCode >= 300) {
|
|
@@ -864,35 +780,19 @@ const deserializeAws_json1_1CreateStudioCommandError = async (output, context) =
|
|
|
864
780
|
switch (errorCode) {
|
|
865
781
|
case "InternalServerException":
|
|
866
782
|
case "com.amazonaws.emr#InternalServerException":
|
|
867
|
-
|
|
868
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
869
|
-
name: errorCode,
|
|
870
|
-
$metadata: deserializeMetadata(output),
|
|
871
|
-
};
|
|
872
|
-
break;
|
|
783
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
873
784
|
case "InvalidRequestException":
|
|
874
785
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
875
|
-
|
|
876
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
877
|
-
name: errorCode,
|
|
878
|
-
$metadata: deserializeMetadata(output),
|
|
879
|
-
};
|
|
880
|
-
break;
|
|
786
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
881
787
|
default:
|
|
882
788
|
const parsedBody = parsedOutput.body;
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
...parsedBody,
|
|
886
|
-
name: `${errorCode}`,
|
|
887
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
789
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
790
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
888
791
|
$fault: "client",
|
|
889
792
|
$metadata: deserializeMetadata(output),
|
|
890
|
-
};
|
|
793
|
+
});
|
|
794
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
891
795
|
}
|
|
892
|
-
const message = response.message || response.Message || errorCode;
|
|
893
|
-
response.message = message;
|
|
894
|
-
delete response.Message;
|
|
895
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
896
796
|
};
|
|
897
797
|
const deserializeAws_json1_1CreateStudioSessionMappingCommand = async (output, context) => {
|
|
898
798
|
if (output.statusCode >= 300) {
|
|
@@ -916,35 +816,19 @@ const deserializeAws_json1_1CreateStudioSessionMappingCommandError = async (outp
|
|
|
916
816
|
switch (errorCode) {
|
|
917
817
|
case "InternalServerError":
|
|
918
818
|
case "com.amazonaws.emr#InternalServerError":
|
|
919
|
-
|
|
920
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
921
|
-
name: errorCode,
|
|
922
|
-
$metadata: deserializeMetadata(output),
|
|
923
|
-
};
|
|
924
|
-
break;
|
|
819
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
925
820
|
case "InvalidRequestException":
|
|
926
821
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
927
|
-
|
|
928
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
929
|
-
name: errorCode,
|
|
930
|
-
$metadata: deserializeMetadata(output),
|
|
931
|
-
};
|
|
932
|
-
break;
|
|
822
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
933
823
|
default:
|
|
934
824
|
const parsedBody = parsedOutput.body;
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
...parsedBody,
|
|
938
|
-
name: `${errorCode}`,
|
|
939
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
825
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
826
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
940
827
|
$fault: "client",
|
|
941
828
|
$metadata: deserializeMetadata(output),
|
|
942
|
-
};
|
|
829
|
+
});
|
|
830
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
943
831
|
}
|
|
944
|
-
const message = response.message || response.Message || errorCode;
|
|
945
|
-
response.message = message;
|
|
946
|
-
delete response.Message;
|
|
947
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
948
832
|
};
|
|
949
833
|
const deserializeAws_json1_1DeleteSecurityConfigurationCommand = async (output, context) => {
|
|
950
834
|
if (output.statusCode >= 300) {
|
|
@@ -971,35 +855,19 @@ const deserializeAws_json1_1DeleteSecurityConfigurationCommandError = async (out
|
|
|
971
855
|
switch (errorCode) {
|
|
972
856
|
case "InternalServerException":
|
|
973
857
|
case "com.amazonaws.emr#InternalServerException":
|
|
974
|
-
|
|
975
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
976
|
-
name: errorCode,
|
|
977
|
-
$metadata: deserializeMetadata(output),
|
|
978
|
-
};
|
|
979
|
-
break;
|
|
858
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
980
859
|
case "InvalidRequestException":
|
|
981
860
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
982
|
-
|
|
983
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
984
|
-
name: errorCode,
|
|
985
|
-
$metadata: deserializeMetadata(output),
|
|
986
|
-
};
|
|
987
|
-
break;
|
|
861
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
988
862
|
default:
|
|
989
863
|
const parsedBody = parsedOutput.body;
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
...parsedBody,
|
|
993
|
-
name: `${errorCode}`,
|
|
994
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
864
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
865
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
995
866
|
$fault: "client",
|
|
996
867
|
$metadata: deserializeMetadata(output),
|
|
997
|
-
};
|
|
868
|
+
});
|
|
869
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
998
870
|
}
|
|
999
|
-
const message = response.message || response.Message || errorCode;
|
|
1000
|
-
response.message = message;
|
|
1001
|
-
delete response.Message;
|
|
1002
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1003
871
|
};
|
|
1004
872
|
const deserializeAws_json1_1DeleteStudioCommand = async (output, context) => {
|
|
1005
873
|
if (output.statusCode >= 300) {
|
|
@@ -1023,35 +891,19 @@ const deserializeAws_json1_1DeleteStudioCommandError = async (output, context) =
|
|
|
1023
891
|
switch (errorCode) {
|
|
1024
892
|
case "InternalServerException":
|
|
1025
893
|
case "com.amazonaws.emr#InternalServerException":
|
|
1026
|
-
|
|
1027
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1028
|
-
name: errorCode,
|
|
1029
|
-
$metadata: deserializeMetadata(output),
|
|
1030
|
-
};
|
|
1031
|
-
break;
|
|
894
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1032
895
|
case "InvalidRequestException":
|
|
1033
896
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1034
|
-
|
|
1035
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1036
|
-
name: errorCode,
|
|
1037
|
-
$metadata: deserializeMetadata(output),
|
|
1038
|
-
};
|
|
1039
|
-
break;
|
|
897
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1040
898
|
default:
|
|
1041
899
|
const parsedBody = parsedOutput.body;
|
|
1042
|
-
|
|
1043
|
-
|
|
1044
|
-
...parsedBody,
|
|
1045
|
-
name: `${errorCode}`,
|
|
1046
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
900
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
901
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1047
902
|
$fault: "client",
|
|
1048
903
|
$metadata: deserializeMetadata(output),
|
|
1049
|
-
};
|
|
904
|
+
});
|
|
905
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1050
906
|
}
|
|
1051
|
-
const message = response.message || response.Message || errorCode;
|
|
1052
|
-
response.message = message;
|
|
1053
|
-
delete response.Message;
|
|
1054
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1055
907
|
};
|
|
1056
908
|
const deserializeAws_json1_1DeleteStudioSessionMappingCommand = async (output, context) => {
|
|
1057
909
|
if (output.statusCode >= 300) {
|
|
@@ -1075,35 +927,19 @@ const deserializeAws_json1_1DeleteStudioSessionMappingCommandError = async (outp
|
|
|
1075
927
|
switch (errorCode) {
|
|
1076
928
|
case "InternalServerError":
|
|
1077
929
|
case "com.amazonaws.emr#InternalServerError":
|
|
1078
|
-
|
|
1079
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1080
|
-
name: errorCode,
|
|
1081
|
-
$metadata: deserializeMetadata(output),
|
|
1082
|
-
};
|
|
1083
|
-
break;
|
|
930
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1084
931
|
case "InvalidRequestException":
|
|
1085
932
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1086
|
-
|
|
1087
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1088
|
-
name: errorCode,
|
|
1089
|
-
$metadata: deserializeMetadata(output),
|
|
1090
|
-
};
|
|
1091
|
-
break;
|
|
933
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1092
934
|
default:
|
|
1093
935
|
const parsedBody = parsedOutput.body;
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
...parsedBody,
|
|
1097
|
-
name: `${errorCode}`,
|
|
1098
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
936
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
937
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1099
938
|
$fault: "client",
|
|
1100
939
|
$metadata: deserializeMetadata(output),
|
|
1101
|
-
};
|
|
940
|
+
});
|
|
941
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1102
942
|
}
|
|
1103
|
-
const message = response.message || response.Message || errorCode;
|
|
1104
|
-
response.message = message;
|
|
1105
|
-
delete response.Message;
|
|
1106
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1107
943
|
};
|
|
1108
944
|
const deserializeAws_json1_1DescribeClusterCommand = async (output, context) => {
|
|
1109
945
|
if (output.statusCode >= 300) {
|
|
@@ -1130,35 +966,19 @@ const deserializeAws_json1_1DescribeClusterCommandError = async (output, context
|
|
|
1130
966
|
switch (errorCode) {
|
|
1131
967
|
case "InternalServerException":
|
|
1132
968
|
case "com.amazonaws.emr#InternalServerException":
|
|
1133
|
-
|
|
1134
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1135
|
-
name: errorCode,
|
|
1136
|
-
$metadata: deserializeMetadata(output),
|
|
1137
|
-
};
|
|
1138
|
-
break;
|
|
969
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1139
970
|
case "InvalidRequestException":
|
|
1140
971
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1141
|
-
|
|
1142
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1143
|
-
name: errorCode,
|
|
1144
|
-
$metadata: deserializeMetadata(output),
|
|
1145
|
-
};
|
|
1146
|
-
break;
|
|
972
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1147
973
|
default:
|
|
1148
974
|
const parsedBody = parsedOutput.body;
|
|
1149
|
-
|
|
1150
|
-
|
|
1151
|
-
...parsedBody,
|
|
1152
|
-
name: `${errorCode}`,
|
|
1153
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
975
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
976
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1154
977
|
$fault: "client",
|
|
1155
978
|
$metadata: deserializeMetadata(output),
|
|
1156
|
-
};
|
|
979
|
+
});
|
|
980
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1157
981
|
}
|
|
1158
|
-
const message = response.message || response.Message || errorCode;
|
|
1159
|
-
response.message = message;
|
|
1160
|
-
delete response.Message;
|
|
1161
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1162
982
|
};
|
|
1163
983
|
const deserializeAws_json1_1DescribeJobFlowsCommand = async (output, context) => {
|
|
1164
984
|
if (output.statusCode >= 300) {
|
|
@@ -1185,27 +1005,16 @@ const deserializeAws_json1_1DescribeJobFlowsCommandError = async (output, contex
|
|
|
1185
1005
|
switch (errorCode) {
|
|
1186
1006
|
case "InternalServerError":
|
|
1187
1007
|
case "com.amazonaws.emr#InternalServerError":
|
|
1188
|
-
|
|
1189
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1190
|
-
name: errorCode,
|
|
1191
|
-
$metadata: deserializeMetadata(output),
|
|
1192
|
-
};
|
|
1193
|
-
break;
|
|
1008
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1194
1009
|
default:
|
|
1195
1010
|
const parsedBody = parsedOutput.body;
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
...parsedBody,
|
|
1199
|
-
name: `${errorCode}`,
|
|
1200
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1011
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1012
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1201
1013
|
$fault: "client",
|
|
1202
1014
|
$metadata: deserializeMetadata(output),
|
|
1203
|
-
};
|
|
1015
|
+
});
|
|
1016
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1204
1017
|
}
|
|
1205
|
-
const message = response.message || response.Message || errorCode;
|
|
1206
|
-
response.message = message;
|
|
1207
|
-
delete response.Message;
|
|
1208
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1209
1018
|
};
|
|
1210
1019
|
const deserializeAws_json1_1DescribeNotebookExecutionCommand = async (output, context) => {
|
|
1211
1020
|
if (output.statusCode >= 300) {
|
|
@@ -1232,35 +1041,19 @@ const deserializeAws_json1_1DescribeNotebookExecutionCommandError = async (outpu
|
|
|
1232
1041
|
switch (errorCode) {
|
|
1233
1042
|
case "InternalServerError":
|
|
1234
1043
|
case "com.amazonaws.emr#InternalServerError":
|
|
1235
|
-
|
|
1236
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1237
|
-
name: errorCode,
|
|
1238
|
-
$metadata: deserializeMetadata(output),
|
|
1239
|
-
};
|
|
1240
|
-
break;
|
|
1044
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1241
1045
|
case "InvalidRequestException":
|
|
1242
1046
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1243
|
-
|
|
1244
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1245
|
-
name: errorCode,
|
|
1246
|
-
$metadata: deserializeMetadata(output),
|
|
1247
|
-
};
|
|
1248
|
-
break;
|
|
1047
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1249
1048
|
default:
|
|
1250
1049
|
const parsedBody = parsedOutput.body;
|
|
1251
|
-
|
|
1252
|
-
|
|
1253
|
-
...parsedBody,
|
|
1254
|
-
name: `${errorCode}`,
|
|
1255
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1050
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1051
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1256
1052
|
$fault: "client",
|
|
1257
1053
|
$metadata: deserializeMetadata(output),
|
|
1258
|
-
};
|
|
1054
|
+
});
|
|
1055
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1259
1056
|
}
|
|
1260
|
-
const message = response.message || response.Message || errorCode;
|
|
1261
|
-
response.message = message;
|
|
1262
|
-
delete response.Message;
|
|
1263
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1264
1057
|
};
|
|
1265
1058
|
const deserializeAws_json1_1DescribeReleaseLabelCommand = async (output, context) => {
|
|
1266
1059
|
if (output.statusCode >= 300) {
|
|
@@ -1287,35 +1080,19 @@ const deserializeAws_json1_1DescribeReleaseLabelCommandError = async (output, co
|
|
|
1287
1080
|
switch (errorCode) {
|
|
1288
1081
|
case "InternalServerException":
|
|
1289
1082
|
case "com.amazonaws.emr#InternalServerException":
|
|
1290
|
-
|
|
1291
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1292
|
-
name: errorCode,
|
|
1293
|
-
$metadata: deserializeMetadata(output),
|
|
1294
|
-
};
|
|
1295
|
-
break;
|
|
1083
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1296
1084
|
case "InvalidRequestException":
|
|
1297
1085
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1298
|
-
|
|
1299
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1300
|
-
name: errorCode,
|
|
1301
|
-
$metadata: deserializeMetadata(output),
|
|
1302
|
-
};
|
|
1303
|
-
break;
|
|
1086
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1304
1087
|
default:
|
|
1305
1088
|
const parsedBody = parsedOutput.body;
|
|
1306
|
-
|
|
1307
|
-
|
|
1308
|
-
...parsedBody,
|
|
1309
|
-
name: `${errorCode}`,
|
|
1310
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1089
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1090
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1311
1091
|
$fault: "client",
|
|
1312
1092
|
$metadata: deserializeMetadata(output),
|
|
1313
|
-
};
|
|
1093
|
+
});
|
|
1094
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1314
1095
|
}
|
|
1315
|
-
const message = response.message || response.Message || errorCode;
|
|
1316
|
-
response.message = message;
|
|
1317
|
-
delete response.Message;
|
|
1318
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1319
1096
|
};
|
|
1320
1097
|
const deserializeAws_json1_1DescribeSecurityConfigurationCommand = async (output, context) => {
|
|
1321
1098
|
if (output.statusCode >= 300) {
|
|
@@ -1342,35 +1119,19 @@ const deserializeAws_json1_1DescribeSecurityConfigurationCommandError = async (o
|
|
|
1342
1119
|
switch (errorCode) {
|
|
1343
1120
|
case "InternalServerException":
|
|
1344
1121
|
case "com.amazonaws.emr#InternalServerException":
|
|
1345
|
-
|
|
1346
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1347
|
-
name: errorCode,
|
|
1348
|
-
$metadata: deserializeMetadata(output),
|
|
1349
|
-
};
|
|
1350
|
-
break;
|
|
1122
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1351
1123
|
case "InvalidRequestException":
|
|
1352
1124
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1353
|
-
|
|
1354
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1355
|
-
name: errorCode,
|
|
1356
|
-
$metadata: deserializeMetadata(output),
|
|
1357
|
-
};
|
|
1358
|
-
break;
|
|
1125
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1359
1126
|
default:
|
|
1360
1127
|
const parsedBody = parsedOutput.body;
|
|
1361
|
-
|
|
1362
|
-
|
|
1363
|
-
...parsedBody,
|
|
1364
|
-
name: `${errorCode}`,
|
|
1365
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1128
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1129
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1366
1130
|
$fault: "client",
|
|
1367
1131
|
$metadata: deserializeMetadata(output),
|
|
1368
|
-
};
|
|
1132
|
+
});
|
|
1133
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1369
1134
|
}
|
|
1370
|
-
const message = response.message || response.Message || errorCode;
|
|
1371
|
-
response.message = message;
|
|
1372
|
-
delete response.Message;
|
|
1373
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1374
1135
|
};
|
|
1375
1136
|
const deserializeAws_json1_1DescribeStepCommand = async (output, context) => {
|
|
1376
1137
|
if (output.statusCode >= 300) {
|
|
@@ -1397,35 +1158,19 @@ const deserializeAws_json1_1DescribeStepCommandError = async (output, context) =
|
|
|
1397
1158
|
switch (errorCode) {
|
|
1398
1159
|
case "InternalServerException":
|
|
1399
1160
|
case "com.amazonaws.emr#InternalServerException":
|
|
1400
|
-
|
|
1401
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1402
|
-
name: errorCode,
|
|
1403
|
-
$metadata: deserializeMetadata(output),
|
|
1404
|
-
};
|
|
1405
|
-
break;
|
|
1161
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1406
1162
|
case "InvalidRequestException":
|
|
1407
1163
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1408
|
-
|
|
1409
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1410
|
-
name: errorCode,
|
|
1411
|
-
$metadata: deserializeMetadata(output),
|
|
1412
|
-
};
|
|
1413
|
-
break;
|
|
1164
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1414
1165
|
default:
|
|
1415
1166
|
const parsedBody = parsedOutput.body;
|
|
1416
|
-
|
|
1417
|
-
|
|
1418
|
-
...parsedBody,
|
|
1419
|
-
name: `${errorCode}`,
|
|
1420
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1167
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1168
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1421
1169
|
$fault: "client",
|
|
1422
1170
|
$metadata: deserializeMetadata(output),
|
|
1423
|
-
};
|
|
1171
|
+
});
|
|
1172
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1424
1173
|
}
|
|
1425
|
-
const message = response.message || response.Message || errorCode;
|
|
1426
|
-
response.message = message;
|
|
1427
|
-
delete response.Message;
|
|
1428
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1429
1174
|
};
|
|
1430
1175
|
const deserializeAws_json1_1DescribeStudioCommand = async (output, context) => {
|
|
1431
1176
|
if (output.statusCode >= 300) {
|
|
@@ -1452,35 +1197,19 @@ const deserializeAws_json1_1DescribeStudioCommandError = async (output, context)
|
|
|
1452
1197
|
switch (errorCode) {
|
|
1453
1198
|
case "InternalServerException":
|
|
1454
1199
|
case "com.amazonaws.emr#InternalServerException":
|
|
1455
|
-
|
|
1456
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1457
|
-
name: errorCode,
|
|
1458
|
-
$metadata: deserializeMetadata(output),
|
|
1459
|
-
};
|
|
1460
|
-
break;
|
|
1200
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1461
1201
|
case "InvalidRequestException":
|
|
1462
1202
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1463
|
-
|
|
1464
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1465
|
-
name: errorCode,
|
|
1466
|
-
$metadata: deserializeMetadata(output),
|
|
1467
|
-
};
|
|
1468
|
-
break;
|
|
1203
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1469
1204
|
default:
|
|
1470
1205
|
const parsedBody = parsedOutput.body;
|
|
1471
|
-
|
|
1472
|
-
|
|
1473
|
-
...parsedBody,
|
|
1474
|
-
name: `${errorCode}`,
|
|
1475
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1206
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1207
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1476
1208
|
$fault: "client",
|
|
1477
1209
|
$metadata: deserializeMetadata(output),
|
|
1478
|
-
};
|
|
1210
|
+
});
|
|
1211
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1479
1212
|
}
|
|
1480
|
-
const message = response.message || response.Message || errorCode;
|
|
1481
|
-
response.message = message;
|
|
1482
|
-
delete response.Message;
|
|
1483
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1484
1213
|
};
|
|
1485
1214
|
const deserializeAws_json1_1GetAutoTerminationPolicyCommand = async (output, context) => {
|
|
1486
1215
|
if (output.statusCode >= 300) {
|
|
@@ -1507,19 +1236,13 @@ const deserializeAws_json1_1GetAutoTerminationPolicyCommandError = async (output
|
|
|
1507
1236
|
switch (errorCode) {
|
|
1508
1237
|
default:
|
|
1509
1238
|
const parsedBody = parsedOutput.body;
|
|
1510
|
-
|
|
1511
|
-
|
|
1512
|
-
...parsedBody,
|
|
1513
|
-
name: `${errorCode}`,
|
|
1514
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1239
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1240
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1515
1241
|
$fault: "client",
|
|
1516
1242
|
$metadata: deserializeMetadata(output),
|
|
1517
|
-
};
|
|
1243
|
+
});
|
|
1244
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1518
1245
|
}
|
|
1519
|
-
const message = response.message || response.Message || errorCode;
|
|
1520
|
-
response.message = message;
|
|
1521
|
-
delete response.Message;
|
|
1522
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1523
1246
|
};
|
|
1524
1247
|
const deserializeAws_json1_1GetBlockPublicAccessConfigurationCommand = async (output, context) => {
|
|
1525
1248
|
if (output.statusCode >= 300) {
|
|
@@ -1546,35 +1269,19 @@ const deserializeAws_json1_1GetBlockPublicAccessConfigurationCommandError = asyn
|
|
|
1546
1269
|
switch (errorCode) {
|
|
1547
1270
|
case "InternalServerException":
|
|
1548
1271
|
case "com.amazonaws.emr#InternalServerException":
|
|
1549
|
-
|
|
1550
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1551
|
-
name: errorCode,
|
|
1552
|
-
$metadata: deserializeMetadata(output),
|
|
1553
|
-
};
|
|
1554
|
-
break;
|
|
1272
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1555
1273
|
case "InvalidRequestException":
|
|
1556
1274
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1557
|
-
|
|
1558
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1559
|
-
name: errorCode,
|
|
1560
|
-
$metadata: deserializeMetadata(output),
|
|
1561
|
-
};
|
|
1562
|
-
break;
|
|
1275
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1563
1276
|
default:
|
|
1564
1277
|
const parsedBody = parsedOutput.body;
|
|
1565
|
-
|
|
1566
|
-
|
|
1567
|
-
...parsedBody,
|
|
1568
|
-
name: `${errorCode}`,
|
|
1569
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1278
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1279
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1570
1280
|
$fault: "client",
|
|
1571
1281
|
$metadata: deserializeMetadata(output),
|
|
1572
|
-
};
|
|
1282
|
+
});
|
|
1283
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1573
1284
|
}
|
|
1574
|
-
const message = response.message || response.Message || errorCode;
|
|
1575
|
-
response.message = message;
|
|
1576
|
-
delete response.Message;
|
|
1577
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1578
1285
|
};
|
|
1579
1286
|
const deserializeAws_json1_1GetManagedScalingPolicyCommand = async (output, context) => {
|
|
1580
1287
|
if (output.statusCode >= 300) {
|
|
@@ -1601,19 +1308,13 @@ const deserializeAws_json1_1GetManagedScalingPolicyCommandError = async (output,
|
|
|
1601
1308
|
switch (errorCode) {
|
|
1602
1309
|
default:
|
|
1603
1310
|
const parsedBody = parsedOutput.body;
|
|
1604
|
-
|
|
1605
|
-
|
|
1606
|
-
...parsedBody,
|
|
1607
|
-
name: `${errorCode}`,
|
|
1608
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1311
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1312
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1609
1313
|
$fault: "client",
|
|
1610
1314
|
$metadata: deserializeMetadata(output),
|
|
1611
|
-
};
|
|
1315
|
+
});
|
|
1316
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1612
1317
|
}
|
|
1613
|
-
const message = response.message || response.Message || errorCode;
|
|
1614
|
-
response.message = message;
|
|
1615
|
-
delete response.Message;
|
|
1616
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1617
1318
|
};
|
|
1618
1319
|
const deserializeAws_json1_1GetStudioSessionMappingCommand = async (output, context) => {
|
|
1619
1320
|
if (output.statusCode >= 300) {
|
|
@@ -1640,35 +1341,19 @@ const deserializeAws_json1_1GetStudioSessionMappingCommandError = async (output,
|
|
|
1640
1341
|
switch (errorCode) {
|
|
1641
1342
|
case "InternalServerError":
|
|
1642
1343
|
case "com.amazonaws.emr#InternalServerError":
|
|
1643
|
-
|
|
1644
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1645
|
-
name: errorCode,
|
|
1646
|
-
$metadata: deserializeMetadata(output),
|
|
1647
|
-
};
|
|
1648
|
-
break;
|
|
1344
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1649
1345
|
case "InvalidRequestException":
|
|
1650
1346
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1651
|
-
|
|
1652
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1653
|
-
name: errorCode,
|
|
1654
|
-
$metadata: deserializeMetadata(output),
|
|
1655
|
-
};
|
|
1656
|
-
break;
|
|
1347
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1657
1348
|
default:
|
|
1658
1349
|
const parsedBody = parsedOutput.body;
|
|
1659
|
-
|
|
1660
|
-
|
|
1661
|
-
...parsedBody,
|
|
1662
|
-
name: `${errorCode}`,
|
|
1663
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1350
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1351
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1664
1352
|
$fault: "client",
|
|
1665
1353
|
$metadata: deserializeMetadata(output),
|
|
1666
|
-
};
|
|
1354
|
+
});
|
|
1355
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1667
1356
|
}
|
|
1668
|
-
const message = response.message || response.Message || errorCode;
|
|
1669
|
-
response.message = message;
|
|
1670
|
-
delete response.Message;
|
|
1671
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1672
1357
|
};
|
|
1673
1358
|
const deserializeAws_json1_1ListBootstrapActionsCommand = async (output, context) => {
|
|
1674
1359
|
if (output.statusCode >= 300) {
|
|
@@ -1695,35 +1380,19 @@ const deserializeAws_json1_1ListBootstrapActionsCommandError = async (output, co
|
|
|
1695
1380
|
switch (errorCode) {
|
|
1696
1381
|
case "InternalServerException":
|
|
1697
1382
|
case "com.amazonaws.emr#InternalServerException":
|
|
1698
|
-
|
|
1699
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1700
|
-
name: errorCode,
|
|
1701
|
-
$metadata: deserializeMetadata(output),
|
|
1702
|
-
};
|
|
1703
|
-
break;
|
|
1383
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1704
1384
|
case "InvalidRequestException":
|
|
1705
1385
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1706
|
-
|
|
1707
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1708
|
-
name: errorCode,
|
|
1709
|
-
$metadata: deserializeMetadata(output),
|
|
1710
|
-
};
|
|
1711
|
-
break;
|
|
1386
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1712
1387
|
default:
|
|
1713
1388
|
const parsedBody = parsedOutput.body;
|
|
1714
|
-
|
|
1715
|
-
|
|
1716
|
-
...parsedBody,
|
|
1717
|
-
name: `${errorCode}`,
|
|
1718
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1389
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1390
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1719
1391
|
$fault: "client",
|
|
1720
1392
|
$metadata: deserializeMetadata(output),
|
|
1721
|
-
};
|
|
1393
|
+
});
|
|
1394
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1722
1395
|
}
|
|
1723
|
-
const message = response.message || response.Message || errorCode;
|
|
1724
|
-
response.message = message;
|
|
1725
|
-
delete response.Message;
|
|
1726
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1727
1396
|
};
|
|
1728
1397
|
const deserializeAws_json1_1ListClustersCommand = async (output, context) => {
|
|
1729
1398
|
if (output.statusCode >= 300) {
|
|
@@ -1750,35 +1419,19 @@ const deserializeAws_json1_1ListClustersCommandError = async (output, context) =
|
|
|
1750
1419
|
switch (errorCode) {
|
|
1751
1420
|
case "InternalServerException":
|
|
1752
1421
|
case "com.amazonaws.emr#InternalServerException":
|
|
1753
|
-
|
|
1754
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1755
|
-
name: errorCode,
|
|
1756
|
-
$metadata: deserializeMetadata(output),
|
|
1757
|
-
};
|
|
1758
|
-
break;
|
|
1422
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1759
1423
|
case "InvalidRequestException":
|
|
1760
1424
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1761
|
-
|
|
1762
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1763
|
-
name: errorCode,
|
|
1764
|
-
$metadata: deserializeMetadata(output),
|
|
1765
|
-
};
|
|
1766
|
-
break;
|
|
1425
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1767
1426
|
default:
|
|
1768
1427
|
const parsedBody = parsedOutput.body;
|
|
1769
|
-
|
|
1770
|
-
|
|
1771
|
-
...parsedBody,
|
|
1772
|
-
name: `${errorCode}`,
|
|
1773
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1428
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1429
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1774
1430
|
$fault: "client",
|
|
1775
1431
|
$metadata: deserializeMetadata(output),
|
|
1776
|
-
};
|
|
1432
|
+
});
|
|
1433
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1777
1434
|
}
|
|
1778
|
-
const message = response.message || response.Message || errorCode;
|
|
1779
|
-
response.message = message;
|
|
1780
|
-
delete response.Message;
|
|
1781
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1782
1435
|
};
|
|
1783
1436
|
const deserializeAws_json1_1ListInstanceFleetsCommand = async (output, context) => {
|
|
1784
1437
|
if (output.statusCode >= 300) {
|
|
@@ -1805,35 +1458,19 @@ const deserializeAws_json1_1ListInstanceFleetsCommandError = async (output, cont
|
|
|
1805
1458
|
switch (errorCode) {
|
|
1806
1459
|
case "InternalServerException":
|
|
1807
1460
|
case "com.amazonaws.emr#InternalServerException":
|
|
1808
|
-
|
|
1809
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1810
|
-
name: errorCode,
|
|
1811
|
-
$metadata: deserializeMetadata(output),
|
|
1812
|
-
};
|
|
1813
|
-
break;
|
|
1461
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1814
1462
|
case "InvalidRequestException":
|
|
1815
1463
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1816
|
-
|
|
1817
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1818
|
-
name: errorCode,
|
|
1819
|
-
$metadata: deserializeMetadata(output),
|
|
1820
|
-
};
|
|
1821
|
-
break;
|
|
1464
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1822
1465
|
default:
|
|
1823
1466
|
const parsedBody = parsedOutput.body;
|
|
1824
|
-
|
|
1825
|
-
|
|
1826
|
-
...parsedBody,
|
|
1827
|
-
name: `${errorCode}`,
|
|
1828
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1467
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1468
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1829
1469
|
$fault: "client",
|
|
1830
1470
|
$metadata: deserializeMetadata(output),
|
|
1831
|
-
};
|
|
1471
|
+
});
|
|
1472
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1832
1473
|
}
|
|
1833
|
-
const message = response.message || response.Message || errorCode;
|
|
1834
|
-
response.message = message;
|
|
1835
|
-
delete response.Message;
|
|
1836
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1837
1474
|
};
|
|
1838
1475
|
const deserializeAws_json1_1ListInstanceGroupsCommand = async (output, context) => {
|
|
1839
1476
|
if (output.statusCode >= 300) {
|
|
@@ -1860,35 +1497,19 @@ const deserializeAws_json1_1ListInstanceGroupsCommandError = async (output, cont
|
|
|
1860
1497
|
switch (errorCode) {
|
|
1861
1498
|
case "InternalServerException":
|
|
1862
1499
|
case "com.amazonaws.emr#InternalServerException":
|
|
1863
|
-
|
|
1864
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1865
|
-
name: errorCode,
|
|
1866
|
-
$metadata: deserializeMetadata(output),
|
|
1867
|
-
};
|
|
1868
|
-
break;
|
|
1500
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1869
1501
|
case "InvalidRequestException":
|
|
1870
1502
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1871
|
-
|
|
1872
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1873
|
-
name: errorCode,
|
|
1874
|
-
$metadata: deserializeMetadata(output),
|
|
1875
|
-
};
|
|
1876
|
-
break;
|
|
1503
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1877
1504
|
default:
|
|
1878
1505
|
const parsedBody = parsedOutput.body;
|
|
1879
|
-
|
|
1880
|
-
|
|
1881
|
-
...parsedBody,
|
|
1882
|
-
name: `${errorCode}`,
|
|
1883
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1506
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1507
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1884
1508
|
$fault: "client",
|
|
1885
1509
|
$metadata: deserializeMetadata(output),
|
|
1886
|
-
};
|
|
1510
|
+
});
|
|
1511
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1887
1512
|
}
|
|
1888
|
-
const message = response.message || response.Message || errorCode;
|
|
1889
|
-
response.message = message;
|
|
1890
|
-
delete response.Message;
|
|
1891
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1892
1513
|
};
|
|
1893
1514
|
const deserializeAws_json1_1ListInstancesCommand = async (output, context) => {
|
|
1894
1515
|
if (output.statusCode >= 300) {
|
|
@@ -1915,35 +1536,19 @@ const deserializeAws_json1_1ListInstancesCommandError = async (output, context)
|
|
|
1915
1536
|
switch (errorCode) {
|
|
1916
1537
|
case "InternalServerException":
|
|
1917
1538
|
case "com.amazonaws.emr#InternalServerException":
|
|
1918
|
-
|
|
1919
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
1920
|
-
name: errorCode,
|
|
1921
|
-
$metadata: deserializeMetadata(output),
|
|
1922
|
-
};
|
|
1923
|
-
break;
|
|
1539
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
1924
1540
|
case "InvalidRequestException":
|
|
1925
1541
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1926
|
-
|
|
1927
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1928
|
-
name: errorCode,
|
|
1929
|
-
$metadata: deserializeMetadata(output),
|
|
1930
|
-
};
|
|
1931
|
-
break;
|
|
1542
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1932
1543
|
default:
|
|
1933
1544
|
const parsedBody = parsedOutput.body;
|
|
1934
|
-
|
|
1935
|
-
|
|
1936
|
-
...parsedBody,
|
|
1937
|
-
name: `${errorCode}`,
|
|
1938
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1545
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1546
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1939
1547
|
$fault: "client",
|
|
1940
1548
|
$metadata: deserializeMetadata(output),
|
|
1941
|
-
};
|
|
1549
|
+
});
|
|
1550
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1942
1551
|
}
|
|
1943
|
-
const message = response.message || response.Message || errorCode;
|
|
1944
|
-
response.message = message;
|
|
1945
|
-
delete response.Message;
|
|
1946
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1947
1552
|
};
|
|
1948
1553
|
const deserializeAws_json1_1ListNotebookExecutionsCommand = async (output, context) => {
|
|
1949
1554
|
if (output.statusCode >= 300) {
|
|
@@ -1970,35 +1575,19 @@ const deserializeAws_json1_1ListNotebookExecutionsCommandError = async (output,
|
|
|
1970
1575
|
switch (errorCode) {
|
|
1971
1576
|
case "InternalServerError":
|
|
1972
1577
|
case "com.amazonaws.emr#InternalServerError":
|
|
1973
|
-
|
|
1974
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1975
|
-
name: errorCode,
|
|
1976
|
-
$metadata: deserializeMetadata(output),
|
|
1977
|
-
};
|
|
1978
|
-
break;
|
|
1578
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1979
1579
|
case "InvalidRequestException":
|
|
1980
1580
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
1981
|
-
|
|
1982
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
1983
|
-
name: errorCode,
|
|
1984
|
-
$metadata: deserializeMetadata(output),
|
|
1985
|
-
};
|
|
1986
|
-
break;
|
|
1581
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
1987
1582
|
default:
|
|
1988
1583
|
const parsedBody = parsedOutput.body;
|
|
1989
|
-
|
|
1990
|
-
|
|
1991
|
-
...parsedBody,
|
|
1992
|
-
name: `${errorCode}`,
|
|
1993
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1584
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1585
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1994
1586
|
$fault: "client",
|
|
1995
1587
|
$metadata: deserializeMetadata(output),
|
|
1996
|
-
};
|
|
1588
|
+
});
|
|
1589
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1997
1590
|
}
|
|
1998
|
-
const message = response.message || response.Message || errorCode;
|
|
1999
|
-
response.message = message;
|
|
2000
|
-
delete response.Message;
|
|
2001
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2002
1591
|
};
|
|
2003
1592
|
const deserializeAws_json1_1ListReleaseLabelsCommand = async (output, context) => {
|
|
2004
1593
|
if (output.statusCode >= 300) {
|
|
@@ -2025,35 +1614,19 @@ const deserializeAws_json1_1ListReleaseLabelsCommandError = async (output, conte
|
|
|
2025
1614
|
switch (errorCode) {
|
|
2026
1615
|
case "InternalServerException":
|
|
2027
1616
|
case "com.amazonaws.emr#InternalServerException":
|
|
2028
|
-
|
|
2029
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
2030
|
-
name: errorCode,
|
|
2031
|
-
$metadata: deserializeMetadata(output),
|
|
2032
|
-
};
|
|
2033
|
-
break;
|
|
1617
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
2034
1618
|
case "InvalidRequestException":
|
|
2035
1619
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2036
|
-
|
|
2037
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2038
|
-
name: errorCode,
|
|
2039
|
-
$metadata: deserializeMetadata(output),
|
|
2040
|
-
};
|
|
2041
|
-
break;
|
|
1620
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2042
1621
|
default:
|
|
2043
1622
|
const parsedBody = parsedOutput.body;
|
|
2044
|
-
|
|
2045
|
-
|
|
2046
|
-
...parsedBody,
|
|
2047
|
-
name: `${errorCode}`,
|
|
2048
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1623
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1624
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2049
1625
|
$fault: "client",
|
|
2050
1626
|
$metadata: deserializeMetadata(output),
|
|
2051
|
-
};
|
|
1627
|
+
});
|
|
1628
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2052
1629
|
}
|
|
2053
|
-
const message = response.message || response.Message || errorCode;
|
|
2054
|
-
response.message = message;
|
|
2055
|
-
delete response.Message;
|
|
2056
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2057
1630
|
};
|
|
2058
1631
|
const deserializeAws_json1_1ListSecurityConfigurationsCommand = async (output, context) => {
|
|
2059
1632
|
if (output.statusCode >= 300) {
|
|
@@ -2080,35 +1653,19 @@ const deserializeAws_json1_1ListSecurityConfigurationsCommandError = async (outp
|
|
|
2080
1653
|
switch (errorCode) {
|
|
2081
1654
|
case "InternalServerException":
|
|
2082
1655
|
case "com.amazonaws.emr#InternalServerException":
|
|
2083
|
-
|
|
2084
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
2085
|
-
name: errorCode,
|
|
2086
|
-
$metadata: deserializeMetadata(output),
|
|
2087
|
-
};
|
|
2088
|
-
break;
|
|
1656
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
2089
1657
|
case "InvalidRequestException":
|
|
2090
1658
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2091
|
-
|
|
2092
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2093
|
-
name: errorCode,
|
|
2094
|
-
$metadata: deserializeMetadata(output),
|
|
2095
|
-
};
|
|
2096
|
-
break;
|
|
1659
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2097
1660
|
default:
|
|
2098
1661
|
const parsedBody = parsedOutput.body;
|
|
2099
|
-
|
|
2100
|
-
|
|
2101
|
-
...parsedBody,
|
|
2102
|
-
name: `${errorCode}`,
|
|
2103
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1662
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1663
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2104
1664
|
$fault: "client",
|
|
2105
1665
|
$metadata: deserializeMetadata(output),
|
|
2106
|
-
};
|
|
1666
|
+
});
|
|
1667
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2107
1668
|
}
|
|
2108
|
-
const message = response.message || response.Message || errorCode;
|
|
2109
|
-
response.message = message;
|
|
2110
|
-
delete response.Message;
|
|
2111
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2112
1669
|
};
|
|
2113
1670
|
const deserializeAws_json1_1ListStepsCommand = async (output, context) => {
|
|
2114
1671
|
if (output.statusCode >= 300) {
|
|
@@ -2135,35 +1692,19 @@ const deserializeAws_json1_1ListStepsCommandError = async (output, context) => {
|
|
|
2135
1692
|
switch (errorCode) {
|
|
2136
1693
|
case "InternalServerException":
|
|
2137
1694
|
case "com.amazonaws.emr#InternalServerException":
|
|
2138
|
-
|
|
2139
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
2140
|
-
name: errorCode,
|
|
2141
|
-
$metadata: deserializeMetadata(output),
|
|
2142
|
-
};
|
|
2143
|
-
break;
|
|
1695
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
2144
1696
|
case "InvalidRequestException":
|
|
2145
1697
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2146
|
-
|
|
2147
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2148
|
-
name: errorCode,
|
|
2149
|
-
$metadata: deserializeMetadata(output),
|
|
2150
|
-
};
|
|
2151
|
-
break;
|
|
1698
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2152
1699
|
default:
|
|
2153
1700
|
const parsedBody = parsedOutput.body;
|
|
2154
|
-
|
|
2155
|
-
|
|
2156
|
-
...parsedBody,
|
|
2157
|
-
name: `${errorCode}`,
|
|
2158
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1701
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1702
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2159
1703
|
$fault: "client",
|
|
2160
1704
|
$metadata: deserializeMetadata(output),
|
|
2161
|
-
};
|
|
1705
|
+
});
|
|
1706
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2162
1707
|
}
|
|
2163
|
-
const message = response.message || response.Message || errorCode;
|
|
2164
|
-
response.message = message;
|
|
2165
|
-
delete response.Message;
|
|
2166
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2167
1708
|
};
|
|
2168
1709
|
const deserializeAws_json1_1ListStudiosCommand = async (output, context) => {
|
|
2169
1710
|
if (output.statusCode >= 300) {
|
|
@@ -2190,35 +1731,19 @@ const deserializeAws_json1_1ListStudiosCommandError = async (output, context) =>
|
|
|
2190
1731
|
switch (errorCode) {
|
|
2191
1732
|
case "InternalServerException":
|
|
2192
1733
|
case "com.amazonaws.emr#InternalServerException":
|
|
2193
|
-
|
|
2194
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
2195
|
-
name: errorCode,
|
|
2196
|
-
$metadata: deserializeMetadata(output),
|
|
2197
|
-
};
|
|
2198
|
-
break;
|
|
1734
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
2199
1735
|
case "InvalidRequestException":
|
|
2200
1736
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2201
|
-
|
|
2202
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2203
|
-
name: errorCode,
|
|
2204
|
-
$metadata: deserializeMetadata(output),
|
|
2205
|
-
};
|
|
2206
|
-
break;
|
|
1737
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2207
1738
|
default:
|
|
2208
1739
|
const parsedBody = parsedOutput.body;
|
|
2209
|
-
|
|
2210
|
-
|
|
2211
|
-
...parsedBody,
|
|
2212
|
-
name: `${errorCode}`,
|
|
2213
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1740
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1741
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2214
1742
|
$fault: "client",
|
|
2215
1743
|
$metadata: deserializeMetadata(output),
|
|
2216
|
-
};
|
|
1744
|
+
});
|
|
1745
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2217
1746
|
}
|
|
2218
|
-
const message = response.message || response.Message || errorCode;
|
|
2219
|
-
response.message = message;
|
|
2220
|
-
delete response.Message;
|
|
2221
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2222
1747
|
};
|
|
2223
1748
|
const deserializeAws_json1_1ListStudioSessionMappingsCommand = async (output, context) => {
|
|
2224
1749
|
if (output.statusCode >= 300) {
|
|
@@ -2245,35 +1770,19 @@ const deserializeAws_json1_1ListStudioSessionMappingsCommandError = async (outpu
|
|
|
2245
1770
|
switch (errorCode) {
|
|
2246
1771
|
case "InternalServerError":
|
|
2247
1772
|
case "com.amazonaws.emr#InternalServerError":
|
|
2248
|
-
|
|
2249
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2250
|
-
name: errorCode,
|
|
2251
|
-
$metadata: deserializeMetadata(output),
|
|
2252
|
-
};
|
|
2253
|
-
break;
|
|
1773
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2254
1774
|
case "InvalidRequestException":
|
|
2255
1775
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2256
|
-
|
|
2257
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2258
|
-
name: errorCode,
|
|
2259
|
-
$metadata: deserializeMetadata(output),
|
|
2260
|
-
};
|
|
2261
|
-
break;
|
|
1776
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2262
1777
|
default:
|
|
2263
1778
|
const parsedBody = parsedOutput.body;
|
|
2264
|
-
|
|
2265
|
-
|
|
2266
|
-
...parsedBody,
|
|
2267
|
-
name: `${errorCode}`,
|
|
2268
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1779
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1780
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2269
1781
|
$fault: "client",
|
|
2270
1782
|
$metadata: deserializeMetadata(output),
|
|
2271
|
-
};
|
|
1783
|
+
});
|
|
1784
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2272
1785
|
}
|
|
2273
|
-
const message = response.message || response.Message || errorCode;
|
|
2274
|
-
response.message = message;
|
|
2275
|
-
delete response.Message;
|
|
2276
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2277
1786
|
};
|
|
2278
1787
|
const deserializeAws_json1_1ModifyClusterCommand = async (output, context) => {
|
|
2279
1788
|
if (output.statusCode >= 300) {
|
|
@@ -2300,35 +1809,19 @@ const deserializeAws_json1_1ModifyClusterCommandError = async (output, context)
|
|
|
2300
1809
|
switch (errorCode) {
|
|
2301
1810
|
case "InternalServerError":
|
|
2302
1811
|
case "com.amazonaws.emr#InternalServerError":
|
|
2303
|
-
|
|
2304
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2305
|
-
name: errorCode,
|
|
2306
|
-
$metadata: deserializeMetadata(output),
|
|
2307
|
-
};
|
|
2308
|
-
break;
|
|
1812
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2309
1813
|
case "InvalidRequestException":
|
|
2310
1814
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2311
|
-
|
|
2312
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2313
|
-
name: errorCode,
|
|
2314
|
-
$metadata: deserializeMetadata(output),
|
|
2315
|
-
};
|
|
2316
|
-
break;
|
|
1815
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2317
1816
|
default:
|
|
2318
1817
|
const parsedBody = parsedOutput.body;
|
|
2319
|
-
|
|
2320
|
-
|
|
2321
|
-
...parsedBody,
|
|
2322
|
-
name: `${errorCode}`,
|
|
2323
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1818
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1819
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2324
1820
|
$fault: "client",
|
|
2325
1821
|
$metadata: deserializeMetadata(output),
|
|
2326
|
-
};
|
|
1822
|
+
});
|
|
1823
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2327
1824
|
}
|
|
2328
|
-
const message = response.message || response.Message || errorCode;
|
|
2329
|
-
response.message = message;
|
|
2330
|
-
delete response.Message;
|
|
2331
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2332
1825
|
};
|
|
2333
1826
|
const deserializeAws_json1_1ModifyInstanceFleetCommand = async (output, context) => {
|
|
2334
1827
|
if (output.statusCode >= 300) {
|
|
@@ -2352,35 +1845,19 @@ const deserializeAws_json1_1ModifyInstanceFleetCommandError = async (output, con
|
|
|
2352
1845
|
switch (errorCode) {
|
|
2353
1846
|
case "InternalServerException":
|
|
2354
1847
|
case "com.amazonaws.emr#InternalServerException":
|
|
2355
|
-
|
|
2356
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
2357
|
-
name: errorCode,
|
|
2358
|
-
$metadata: deserializeMetadata(output),
|
|
2359
|
-
};
|
|
2360
|
-
break;
|
|
1848
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
2361
1849
|
case "InvalidRequestException":
|
|
2362
1850
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2363
|
-
|
|
2364
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2365
|
-
name: errorCode,
|
|
2366
|
-
$metadata: deserializeMetadata(output),
|
|
2367
|
-
};
|
|
2368
|
-
break;
|
|
1851
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2369
1852
|
default:
|
|
2370
1853
|
const parsedBody = parsedOutput.body;
|
|
2371
|
-
|
|
2372
|
-
|
|
2373
|
-
...parsedBody,
|
|
2374
|
-
name: `${errorCode}`,
|
|
2375
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1854
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1855
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2376
1856
|
$fault: "client",
|
|
2377
1857
|
$metadata: deserializeMetadata(output),
|
|
2378
|
-
};
|
|
1858
|
+
});
|
|
1859
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2379
1860
|
}
|
|
2380
|
-
const message = response.message || response.Message || errorCode;
|
|
2381
|
-
response.message = message;
|
|
2382
|
-
delete response.Message;
|
|
2383
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2384
1861
|
};
|
|
2385
1862
|
const deserializeAws_json1_1ModifyInstanceGroupsCommand = async (output, context) => {
|
|
2386
1863
|
if (output.statusCode >= 300) {
|
|
@@ -2404,27 +1881,16 @@ const deserializeAws_json1_1ModifyInstanceGroupsCommandError = async (output, co
|
|
|
2404
1881
|
switch (errorCode) {
|
|
2405
1882
|
case "InternalServerError":
|
|
2406
1883
|
case "com.amazonaws.emr#InternalServerError":
|
|
2407
|
-
|
|
2408
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2409
|
-
name: errorCode,
|
|
2410
|
-
$metadata: deserializeMetadata(output),
|
|
2411
|
-
};
|
|
2412
|
-
break;
|
|
1884
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2413
1885
|
default:
|
|
2414
1886
|
const parsedBody = parsedOutput.body;
|
|
2415
|
-
|
|
2416
|
-
|
|
2417
|
-
...parsedBody,
|
|
2418
|
-
name: `${errorCode}`,
|
|
2419
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1887
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1888
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2420
1889
|
$fault: "client",
|
|
2421
1890
|
$metadata: deserializeMetadata(output),
|
|
2422
|
-
};
|
|
1891
|
+
});
|
|
1892
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2423
1893
|
}
|
|
2424
|
-
const message = response.message || response.Message || errorCode;
|
|
2425
|
-
response.message = message;
|
|
2426
|
-
delete response.Message;
|
|
2427
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2428
1894
|
};
|
|
2429
1895
|
const deserializeAws_json1_1PutAutoScalingPolicyCommand = async (output, context) => {
|
|
2430
1896
|
if (output.statusCode >= 300) {
|
|
@@ -2451,19 +1917,13 @@ const deserializeAws_json1_1PutAutoScalingPolicyCommandError = async (output, co
|
|
|
2451
1917
|
switch (errorCode) {
|
|
2452
1918
|
default:
|
|
2453
1919
|
const parsedBody = parsedOutput.body;
|
|
2454
|
-
|
|
2455
|
-
|
|
2456
|
-
...parsedBody,
|
|
2457
|
-
name: `${errorCode}`,
|
|
2458
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1920
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1921
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2459
1922
|
$fault: "client",
|
|
2460
1923
|
$metadata: deserializeMetadata(output),
|
|
2461
|
-
};
|
|
1924
|
+
});
|
|
1925
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2462
1926
|
}
|
|
2463
|
-
const message = response.message || response.Message || errorCode;
|
|
2464
|
-
response.message = message;
|
|
2465
|
-
delete response.Message;
|
|
2466
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2467
1927
|
};
|
|
2468
1928
|
const deserializeAws_json1_1PutAutoTerminationPolicyCommand = async (output, context) => {
|
|
2469
1929
|
if (output.statusCode >= 300) {
|
|
@@ -2490,19 +1950,13 @@ const deserializeAws_json1_1PutAutoTerminationPolicyCommandError = async (output
|
|
|
2490
1950
|
switch (errorCode) {
|
|
2491
1951
|
default:
|
|
2492
1952
|
const parsedBody = parsedOutput.body;
|
|
2493
|
-
|
|
2494
|
-
|
|
2495
|
-
...parsedBody,
|
|
2496
|
-
name: `${errorCode}`,
|
|
2497
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1953
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1954
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2498
1955
|
$fault: "client",
|
|
2499
1956
|
$metadata: deserializeMetadata(output),
|
|
2500
|
-
};
|
|
1957
|
+
});
|
|
1958
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2501
1959
|
}
|
|
2502
|
-
const message = response.message || response.Message || errorCode;
|
|
2503
|
-
response.message = message;
|
|
2504
|
-
delete response.Message;
|
|
2505
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2506
1960
|
};
|
|
2507
1961
|
const deserializeAws_json1_1PutBlockPublicAccessConfigurationCommand = async (output, context) => {
|
|
2508
1962
|
if (output.statusCode >= 300) {
|
|
@@ -2529,35 +1983,19 @@ const deserializeAws_json1_1PutBlockPublicAccessConfigurationCommandError = asyn
|
|
|
2529
1983
|
switch (errorCode) {
|
|
2530
1984
|
case "InternalServerException":
|
|
2531
1985
|
case "com.amazonaws.emr#InternalServerException":
|
|
2532
|
-
|
|
2533
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
2534
|
-
name: errorCode,
|
|
2535
|
-
$metadata: deserializeMetadata(output),
|
|
2536
|
-
};
|
|
2537
|
-
break;
|
|
1986
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
2538
1987
|
case "InvalidRequestException":
|
|
2539
1988
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2540
|
-
|
|
2541
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2542
|
-
name: errorCode,
|
|
2543
|
-
$metadata: deserializeMetadata(output),
|
|
2544
|
-
};
|
|
2545
|
-
break;
|
|
1989
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2546
1990
|
default:
|
|
2547
1991
|
const parsedBody = parsedOutput.body;
|
|
2548
|
-
|
|
2549
|
-
|
|
2550
|
-
...parsedBody,
|
|
2551
|
-
name: `${errorCode}`,
|
|
2552
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1992
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
1993
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2553
1994
|
$fault: "client",
|
|
2554
1995
|
$metadata: deserializeMetadata(output),
|
|
2555
|
-
};
|
|
1996
|
+
});
|
|
1997
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2556
1998
|
}
|
|
2557
|
-
const message = response.message || response.Message || errorCode;
|
|
2558
|
-
response.message = message;
|
|
2559
|
-
delete response.Message;
|
|
2560
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2561
1999
|
};
|
|
2562
2000
|
const deserializeAws_json1_1PutManagedScalingPolicyCommand = async (output, context) => {
|
|
2563
2001
|
if (output.statusCode >= 300) {
|
|
@@ -2584,19 +2022,13 @@ const deserializeAws_json1_1PutManagedScalingPolicyCommandError = async (output,
|
|
|
2584
2022
|
switch (errorCode) {
|
|
2585
2023
|
default:
|
|
2586
2024
|
const parsedBody = parsedOutput.body;
|
|
2587
|
-
|
|
2588
|
-
|
|
2589
|
-
...parsedBody,
|
|
2590
|
-
name: `${errorCode}`,
|
|
2591
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2025
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2026
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2592
2027
|
$fault: "client",
|
|
2593
2028
|
$metadata: deserializeMetadata(output),
|
|
2594
|
-
};
|
|
2029
|
+
});
|
|
2030
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2595
2031
|
}
|
|
2596
|
-
const message = response.message || response.Message || errorCode;
|
|
2597
|
-
response.message = message;
|
|
2598
|
-
delete response.Message;
|
|
2599
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2600
2032
|
};
|
|
2601
2033
|
const deserializeAws_json1_1RemoveAutoScalingPolicyCommand = async (output, context) => {
|
|
2602
2034
|
if (output.statusCode >= 300) {
|
|
@@ -2623,19 +2055,13 @@ const deserializeAws_json1_1RemoveAutoScalingPolicyCommandError = async (output,
|
|
|
2623
2055
|
switch (errorCode) {
|
|
2624
2056
|
default:
|
|
2625
2057
|
const parsedBody = parsedOutput.body;
|
|
2626
|
-
|
|
2627
|
-
|
|
2628
|
-
...parsedBody,
|
|
2629
|
-
name: `${errorCode}`,
|
|
2630
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2058
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2059
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2631
2060
|
$fault: "client",
|
|
2632
2061
|
$metadata: deserializeMetadata(output),
|
|
2633
|
-
};
|
|
2062
|
+
});
|
|
2063
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2634
2064
|
}
|
|
2635
|
-
const message = response.message || response.Message || errorCode;
|
|
2636
|
-
response.message = message;
|
|
2637
|
-
delete response.Message;
|
|
2638
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2639
2065
|
};
|
|
2640
2066
|
const deserializeAws_json1_1RemoveAutoTerminationPolicyCommand = async (output, context) => {
|
|
2641
2067
|
if (output.statusCode >= 300) {
|
|
@@ -2662,19 +2088,13 @@ const deserializeAws_json1_1RemoveAutoTerminationPolicyCommandError = async (out
|
|
|
2662
2088
|
switch (errorCode) {
|
|
2663
2089
|
default:
|
|
2664
2090
|
const parsedBody = parsedOutput.body;
|
|
2665
|
-
|
|
2666
|
-
|
|
2667
|
-
...parsedBody,
|
|
2668
|
-
name: `${errorCode}`,
|
|
2669
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2091
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2092
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2670
2093
|
$fault: "client",
|
|
2671
2094
|
$metadata: deserializeMetadata(output),
|
|
2672
|
-
};
|
|
2095
|
+
});
|
|
2096
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2673
2097
|
}
|
|
2674
|
-
const message = response.message || response.Message || errorCode;
|
|
2675
|
-
response.message = message;
|
|
2676
|
-
delete response.Message;
|
|
2677
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2678
2098
|
};
|
|
2679
2099
|
const deserializeAws_json1_1RemoveManagedScalingPolicyCommand = async (output, context) => {
|
|
2680
2100
|
if (output.statusCode >= 300) {
|
|
@@ -2701,19 +2121,13 @@ const deserializeAws_json1_1RemoveManagedScalingPolicyCommandError = async (outp
|
|
|
2701
2121
|
switch (errorCode) {
|
|
2702
2122
|
default:
|
|
2703
2123
|
const parsedBody = parsedOutput.body;
|
|
2704
|
-
|
|
2705
|
-
|
|
2706
|
-
...parsedBody,
|
|
2707
|
-
name: `${errorCode}`,
|
|
2708
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2124
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2125
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2709
2126
|
$fault: "client",
|
|
2710
2127
|
$metadata: deserializeMetadata(output),
|
|
2711
|
-
};
|
|
2128
|
+
});
|
|
2129
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2712
2130
|
}
|
|
2713
|
-
const message = response.message || response.Message || errorCode;
|
|
2714
|
-
response.message = message;
|
|
2715
|
-
delete response.Message;
|
|
2716
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2717
2131
|
};
|
|
2718
2132
|
const deserializeAws_json1_1RemoveTagsCommand = async (output, context) => {
|
|
2719
2133
|
if (output.statusCode >= 300) {
|
|
@@ -2740,35 +2154,19 @@ const deserializeAws_json1_1RemoveTagsCommandError = async (output, context) =>
|
|
|
2740
2154
|
switch (errorCode) {
|
|
2741
2155
|
case "InternalServerException":
|
|
2742
2156
|
case "com.amazonaws.emr#InternalServerException":
|
|
2743
|
-
|
|
2744
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
2745
|
-
name: errorCode,
|
|
2746
|
-
$metadata: deserializeMetadata(output),
|
|
2747
|
-
};
|
|
2748
|
-
break;
|
|
2157
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
2749
2158
|
case "InvalidRequestException":
|
|
2750
2159
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2751
|
-
|
|
2752
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2753
|
-
name: errorCode,
|
|
2754
|
-
$metadata: deserializeMetadata(output),
|
|
2755
|
-
};
|
|
2756
|
-
break;
|
|
2160
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2757
2161
|
default:
|
|
2758
2162
|
const parsedBody = parsedOutput.body;
|
|
2759
|
-
|
|
2760
|
-
|
|
2761
|
-
...parsedBody,
|
|
2762
|
-
name: `${errorCode}`,
|
|
2763
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2163
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2164
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2764
2165
|
$fault: "client",
|
|
2765
2166
|
$metadata: deserializeMetadata(output),
|
|
2766
|
-
};
|
|
2167
|
+
});
|
|
2168
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2767
2169
|
}
|
|
2768
|
-
const message = response.message || response.Message || errorCode;
|
|
2769
|
-
response.message = message;
|
|
2770
|
-
delete response.Message;
|
|
2771
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2772
2170
|
};
|
|
2773
2171
|
const deserializeAws_json1_1RunJobFlowCommand = async (output, context) => {
|
|
2774
2172
|
if (output.statusCode >= 300) {
|
|
@@ -2795,27 +2193,16 @@ const deserializeAws_json1_1RunJobFlowCommandError = async (output, context) =>
|
|
|
2795
2193
|
switch (errorCode) {
|
|
2796
2194
|
case "InternalServerError":
|
|
2797
2195
|
case "com.amazonaws.emr#InternalServerError":
|
|
2798
|
-
|
|
2799
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2800
|
-
name: errorCode,
|
|
2801
|
-
$metadata: deserializeMetadata(output),
|
|
2802
|
-
};
|
|
2803
|
-
break;
|
|
2196
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2804
2197
|
default:
|
|
2805
2198
|
const parsedBody = parsedOutput.body;
|
|
2806
|
-
|
|
2807
|
-
|
|
2808
|
-
...parsedBody,
|
|
2809
|
-
name: `${errorCode}`,
|
|
2810
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2199
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2200
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2811
2201
|
$fault: "client",
|
|
2812
2202
|
$metadata: deserializeMetadata(output),
|
|
2813
|
-
};
|
|
2203
|
+
});
|
|
2204
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2814
2205
|
}
|
|
2815
|
-
const message = response.message || response.Message || errorCode;
|
|
2816
|
-
response.message = message;
|
|
2817
|
-
delete response.Message;
|
|
2818
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2819
2206
|
};
|
|
2820
2207
|
const deserializeAws_json1_1SetTerminationProtectionCommand = async (output, context) => {
|
|
2821
2208
|
if (output.statusCode >= 300) {
|
|
@@ -2839,27 +2226,16 @@ const deserializeAws_json1_1SetTerminationProtectionCommandError = async (output
|
|
|
2839
2226
|
switch (errorCode) {
|
|
2840
2227
|
case "InternalServerError":
|
|
2841
2228
|
case "com.amazonaws.emr#InternalServerError":
|
|
2842
|
-
|
|
2843
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2844
|
-
name: errorCode,
|
|
2845
|
-
$metadata: deserializeMetadata(output),
|
|
2846
|
-
};
|
|
2847
|
-
break;
|
|
2229
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2848
2230
|
default:
|
|
2849
2231
|
const parsedBody = parsedOutput.body;
|
|
2850
|
-
|
|
2851
|
-
|
|
2852
|
-
...parsedBody,
|
|
2853
|
-
name: `${errorCode}`,
|
|
2854
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2232
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2233
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2855
2234
|
$fault: "client",
|
|
2856
2235
|
$metadata: deserializeMetadata(output),
|
|
2857
|
-
};
|
|
2236
|
+
});
|
|
2237
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2858
2238
|
}
|
|
2859
|
-
const message = response.message || response.Message || errorCode;
|
|
2860
|
-
response.message = message;
|
|
2861
|
-
delete response.Message;
|
|
2862
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2863
2239
|
};
|
|
2864
2240
|
const deserializeAws_json1_1SetVisibleToAllUsersCommand = async (output, context) => {
|
|
2865
2241
|
if (output.statusCode >= 300) {
|
|
@@ -2883,27 +2259,16 @@ const deserializeAws_json1_1SetVisibleToAllUsersCommandError = async (output, co
|
|
|
2883
2259
|
switch (errorCode) {
|
|
2884
2260
|
case "InternalServerError":
|
|
2885
2261
|
case "com.amazonaws.emr#InternalServerError":
|
|
2886
|
-
|
|
2887
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2888
|
-
name: errorCode,
|
|
2889
|
-
$metadata: deserializeMetadata(output),
|
|
2890
|
-
};
|
|
2891
|
-
break;
|
|
2262
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2892
2263
|
default:
|
|
2893
2264
|
const parsedBody = parsedOutput.body;
|
|
2894
|
-
|
|
2895
|
-
|
|
2896
|
-
...parsedBody,
|
|
2897
|
-
name: `${errorCode}`,
|
|
2898
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2265
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2266
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2899
2267
|
$fault: "client",
|
|
2900
2268
|
$metadata: deserializeMetadata(output),
|
|
2901
|
-
};
|
|
2269
|
+
});
|
|
2270
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2902
2271
|
}
|
|
2903
|
-
const message = response.message || response.Message || errorCode;
|
|
2904
|
-
response.message = message;
|
|
2905
|
-
delete response.Message;
|
|
2906
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2907
2272
|
};
|
|
2908
2273
|
const deserializeAws_json1_1StartNotebookExecutionCommand = async (output, context) => {
|
|
2909
2274
|
if (output.statusCode >= 300) {
|
|
@@ -2930,35 +2295,19 @@ const deserializeAws_json1_1StartNotebookExecutionCommandError = async (output,
|
|
|
2930
2295
|
switch (errorCode) {
|
|
2931
2296
|
case "InternalServerException":
|
|
2932
2297
|
case "com.amazonaws.emr#InternalServerException":
|
|
2933
|
-
|
|
2934
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
2935
|
-
name: errorCode,
|
|
2936
|
-
$metadata: deserializeMetadata(output),
|
|
2937
|
-
};
|
|
2938
|
-
break;
|
|
2298
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
2939
2299
|
case "InvalidRequestException":
|
|
2940
2300
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2941
|
-
|
|
2942
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2943
|
-
name: errorCode,
|
|
2944
|
-
$metadata: deserializeMetadata(output),
|
|
2945
|
-
};
|
|
2946
|
-
break;
|
|
2301
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2947
2302
|
default:
|
|
2948
2303
|
const parsedBody = parsedOutput.body;
|
|
2949
|
-
|
|
2950
|
-
|
|
2951
|
-
...parsedBody,
|
|
2952
|
-
name: `${errorCode}`,
|
|
2953
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2304
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2305
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2954
2306
|
$fault: "client",
|
|
2955
2307
|
$metadata: deserializeMetadata(output),
|
|
2956
|
-
};
|
|
2308
|
+
});
|
|
2309
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2957
2310
|
}
|
|
2958
|
-
const message = response.message || response.Message || errorCode;
|
|
2959
|
-
response.message = message;
|
|
2960
|
-
delete response.Message;
|
|
2961
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2962
2311
|
};
|
|
2963
2312
|
const deserializeAws_json1_1StopNotebookExecutionCommand = async (output, context) => {
|
|
2964
2313
|
if (output.statusCode >= 300) {
|
|
@@ -2982,35 +2331,19 @@ const deserializeAws_json1_1StopNotebookExecutionCommandError = async (output, c
|
|
|
2982
2331
|
switch (errorCode) {
|
|
2983
2332
|
case "InternalServerError":
|
|
2984
2333
|
case "com.amazonaws.emr#InternalServerError":
|
|
2985
|
-
|
|
2986
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2987
|
-
name: errorCode,
|
|
2988
|
-
$metadata: deserializeMetadata(output),
|
|
2989
|
-
};
|
|
2990
|
-
break;
|
|
2334
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2991
2335
|
case "InvalidRequestException":
|
|
2992
2336
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
2993
|
-
|
|
2994
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
2995
|
-
name: errorCode,
|
|
2996
|
-
$metadata: deserializeMetadata(output),
|
|
2997
|
-
};
|
|
2998
|
-
break;
|
|
2337
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
2999
2338
|
default:
|
|
3000
2339
|
const parsedBody = parsedOutput.body;
|
|
3001
|
-
|
|
3002
|
-
|
|
3003
|
-
...parsedBody,
|
|
3004
|
-
name: `${errorCode}`,
|
|
3005
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2340
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2341
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3006
2342
|
$fault: "client",
|
|
3007
2343
|
$metadata: deserializeMetadata(output),
|
|
3008
|
-
};
|
|
2344
|
+
});
|
|
2345
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3009
2346
|
}
|
|
3010
|
-
const message = response.message || response.Message || errorCode;
|
|
3011
|
-
response.message = message;
|
|
3012
|
-
delete response.Message;
|
|
3013
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3014
2347
|
};
|
|
3015
2348
|
const deserializeAws_json1_1TerminateJobFlowsCommand = async (output, context) => {
|
|
3016
2349
|
if (output.statusCode >= 300) {
|
|
@@ -3034,27 +2367,16 @@ const deserializeAws_json1_1TerminateJobFlowsCommandError = async (output, conte
|
|
|
3034
2367
|
switch (errorCode) {
|
|
3035
2368
|
case "InternalServerError":
|
|
3036
2369
|
case "com.amazonaws.emr#InternalServerError":
|
|
3037
|
-
|
|
3038
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3039
|
-
name: errorCode,
|
|
3040
|
-
$metadata: deserializeMetadata(output),
|
|
3041
|
-
};
|
|
3042
|
-
break;
|
|
2370
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3043
2371
|
default:
|
|
3044
2372
|
const parsedBody = parsedOutput.body;
|
|
3045
|
-
|
|
3046
|
-
|
|
3047
|
-
...parsedBody,
|
|
3048
|
-
name: `${errorCode}`,
|
|
3049
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2373
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2374
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3050
2375
|
$fault: "client",
|
|
3051
2376
|
$metadata: deserializeMetadata(output),
|
|
3052
|
-
};
|
|
2377
|
+
});
|
|
2378
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3053
2379
|
}
|
|
3054
|
-
const message = response.message || response.Message || errorCode;
|
|
3055
|
-
response.message = message;
|
|
3056
|
-
delete response.Message;
|
|
3057
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3058
2380
|
};
|
|
3059
2381
|
const deserializeAws_json1_1UpdateStudioCommand = async (output, context) => {
|
|
3060
2382
|
if (output.statusCode >= 300) {
|
|
@@ -3078,35 +2400,19 @@ const deserializeAws_json1_1UpdateStudioCommandError = async (output, context) =
|
|
|
3078
2400
|
switch (errorCode) {
|
|
3079
2401
|
case "InternalServerException":
|
|
3080
2402
|
case "com.amazonaws.emr#InternalServerException":
|
|
3081
|
-
|
|
3082
|
-
...(await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context)),
|
|
3083
|
-
name: errorCode,
|
|
3084
|
-
$metadata: deserializeMetadata(output),
|
|
3085
|
-
};
|
|
3086
|
-
break;
|
|
2403
|
+
throw await deserializeAws_json1_1InternalServerExceptionResponse(parsedOutput, context);
|
|
3087
2404
|
case "InvalidRequestException":
|
|
3088
2405
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
3089
|
-
|
|
3090
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
3091
|
-
name: errorCode,
|
|
3092
|
-
$metadata: deserializeMetadata(output),
|
|
3093
|
-
};
|
|
3094
|
-
break;
|
|
2406
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
3095
2407
|
default:
|
|
3096
2408
|
const parsedBody = parsedOutput.body;
|
|
3097
|
-
|
|
3098
|
-
|
|
3099
|
-
...parsedBody,
|
|
3100
|
-
name: `${errorCode}`,
|
|
3101
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2409
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2410
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3102
2411
|
$fault: "client",
|
|
3103
2412
|
$metadata: deserializeMetadata(output),
|
|
3104
|
-
};
|
|
2413
|
+
});
|
|
2414
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3105
2415
|
}
|
|
3106
|
-
const message = response.message || response.Message || errorCode;
|
|
3107
|
-
response.message = message;
|
|
3108
|
-
delete response.Message;
|
|
3109
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3110
2416
|
};
|
|
3111
2417
|
const deserializeAws_json1_1UpdateStudioSessionMappingCommand = async (output, context) => {
|
|
3112
2418
|
if (output.statusCode >= 300) {
|
|
@@ -3130,68 +2436,46 @@ const deserializeAws_json1_1UpdateStudioSessionMappingCommandError = async (outp
|
|
|
3130
2436
|
switch (errorCode) {
|
|
3131
2437
|
case "InternalServerError":
|
|
3132
2438
|
case "com.amazonaws.emr#InternalServerError":
|
|
3133
|
-
|
|
3134
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3135
|
-
name: errorCode,
|
|
3136
|
-
$metadata: deserializeMetadata(output),
|
|
3137
|
-
};
|
|
3138
|
-
break;
|
|
2439
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3139
2440
|
case "InvalidRequestException":
|
|
3140
2441
|
case "com.amazonaws.emr#InvalidRequestException":
|
|
3141
|
-
|
|
3142
|
-
...(await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context)),
|
|
3143
|
-
name: errorCode,
|
|
3144
|
-
$metadata: deserializeMetadata(output),
|
|
3145
|
-
};
|
|
3146
|
-
break;
|
|
2442
|
+
throw await deserializeAws_json1_1InvalidRequestExceptionResponse(parsedOutput, context);
|
|
3147
2443
|
default:
|
|
3148
2444
|
const parsedBody = parsedOutput.body;
|
|
3149
|
-
|
|
3150
|
-
|
|
3151
|
-
...parsedBody,
|
|
3152
|
-
name: `${errorCode}`,
|
|
3153
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2445
|
+
response = new EMRServiceException_1.EMRServiceException({
|
|
2446
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3154
2447
|
$fault: "client",
|
|
3155
2448
|
$metadata: deserializeMetadata(output),
|
|
3156
|
-
};
|
|
2449
|
+
});
|
|
2450
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3157
2451
|
}
|
|
3158
|
-
const message = response.message || response.Message || errorCode;
|
|
3159
|
-
response.message = message;
|
|
3160
|
-
delete response.Message;
|
|
3161
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3162
2452
|
};
|
|
3163
2453
|
const deserializeAws_json1_1InternalServerErrorResponse = async (parsedOutput, context) => {
|
|
3164
2454
|
const body = parsedOutput.body;
|
|
3165
2455
|
const deserialized = deserializeAws_json1_1InternalServerError(body, context);
|
|
3166
|
-
const
|
|
3167
|
-
name: "InternalServerError",
|
|
3168
|
-
$fault: "server",
|
|
2456
|
+
const exception = new models_0_1.InternalServerError({
|
|
3169
2457
|
$metadata: deserializeMetadata(parsedOutput),
|
|
3170
2458
|
...deserialized,
|
|
3171
|
-
};
|
|
3172
|
-
return
|
|
2459
|
+
});
|
|
2460
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
3173
2461
|
};
|
|
3174
2462
|
const deserializeAws_json1_1InternalServerExceptionResponse = async (parsedOutput, context) => {
|
|
3175
2463
|
const body = parsedOutput.body;
|
|
3176
2464
|
const deserialized = deserializeAws_json1_1InternalServerException(body, context);
|
|
3177
|
-
const
|
|
3178
|
-
name: "InternalServerException",
|
|
3179
|
-
$fault: "server",
|
|
2465
|
+
const exception = new models_0_1.InternalServerException({
|
|
3180
2466
|
$metadata: deserializeMetadata(parsedOutput),
|
|
3181
2467
|
...deserialized,
|
|
3182
|
-
};
|
|
3183
|
-
return
|
|
2468
|
+
});
|
|
2469
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
3184
2470
|
};
|
|
3185
2471
|
const deserializeAws_json1_1InvalidRequestExceptionResponse = async (parsedOutput, context) => {
|
|
3186
2472
|
const body = parsedOutput.body;
|
|
3187
2473
|
const deserialized = deserializeAws_json1_1InvalidRequestException(body, context);
|
|
3188
|
-
const
|
|
3189
|
-
name: "InvalidRequestException",
|
|
3190
|
-
$fault: "client",
|
|
2474
|
+
const exception = new models_0_1.InvalidRequestException({
|
|
3191
2475
|
$metadata: deserializeMetadata(parsedOutput),
|
|
3192
2476
|
...deserialized,
|
|
3193
|
-
};
|
|
3194
|
-
return
|
|
2477
|
+
});
|
|
2478
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
3195
2479
|
};
|
|
3196
2480
|
const serializeAws_json1_1AddInstanceFleetInput = (input, context) => {
|
|
3197
2481
|
return {
|
|
@@ -4519,7 +3803,7 @@ const deserializeAws_json1_1Application = (output, context) => {
|
|
|
4519
3803
|
};
|
|
4520
3804
|
};
|
|
4521
3805
|
const deserializeAws_json1_1ApplicationList = (output, context) => {
|
|
4522
|
-
|
|
3806
|
+
const retVal = (output || [])
|
|
4523
3807
|
.filter((e) => e != null)
|
|
4524
3808
|
.map((entry) => {
|
|
4525
3809
|
if (entry === null) {
|
|
@@ -4527,6 +3811,7 @@ const deserializeAws_json1_1ApplicationList = (output, context) => {
|
|
|
4527
3811
|
}
|
|
4528
3812
|
return deserializeAws_json1_1Application(entry, context);
|
|
4529
3813
|
});
|
|
3814
|
+
return retVal;
|
|
4530
3815
|
};
|
|
4531
3816
|
const deserializeAws_json1_1AutoScalingPolicyDescription = (output, context) => {
|
|
4532
3817
|
return {
|
|
@@ -4600,7 +3885,7 @@ const deserializeAws_json1_1BootstrapActionDetail = (output, context) => {
|
|
|
4600
3885
|
};
|
|
4601
3886
|
};
|
|
4602
3887
|
const deserializeAws_json1_1BootstrapActionDetailList = (output, context) => {
|
|
4603
|
-
|
|
3888
|
+
const retVal = (output || [])
|
|
4604
3889
|
.filter((e) => e != null)
|
|
4605
3890
|
.map((entry) => {
|
|
4606
3891
|
if (entry === null) {
|
|
@@ -4608,6 +3893,7 @@ const deserializeAws_json1_1BootstrapActionDetailList = (output, context) => {
|
|
|
4608
3893
|
}
|
|
4609
3894
|
return deserializeAws_json1_1BootstrapActionDetail(entry, context);
|
|
4610
3895
|
});
|
|
3896
|
+
return retVal;
|
|
4611
3897
|
};
|
|
4612
3898
|
const deserializeAws_json1_1CancelStepsInfo = (output, context) => {
|
|
4613
3899
|
return {
|
|
@@ -4617,7 +3903,7 @@ const deserializeAws_json1_1CancelStepsInfo = (output, context) => {
|
|
|
4617
3903
|
};
|
|
4618
3904
|
};
|
|
4619
3905
|
const deserializeAws_json1_1CancelStepsInfoList = (output, context) => {
|
|
4620
|
-
|
|
3906
|
+
const retVal = (output || [])
|
|
4621
3907
|
.filter((e) => e != null)
|
|
4622
3908
|
.map((entry) => {
|
|
4623
3909
|
if (entry === null) {
|
|
@@ -4625,6 +3911,7 @@ const deserializeAws_json1_1CancelStepsInfoList = (output, context) => {
|
|
|
4625
3911
|
}
|
|
4626
3912
|
return deserializeAws_json1_1CancelStepsInfo(entry, context);
|
|
4627
3913
|
});
|
|
3914
|
+
return retVal;
|
|
4628
3915
|
};
|
|
4629
3916
|
const deserializeAws_json1_1CancelStepsOutput = (output, context) => {
|
|
4630
3917
|
return {
|
|
@@ -4726,7 +4013,7 @@ const deserializeAws_json1_1ClusterSummary = (output, context) => {
|
|
|
4726
4013
|
};
|
|
4727
4014
|
};
|
|
4728
4015
|
const deserializeAws_json1_1ClusterSummaryList = (output, context) => {
|
|
4729
|
-
|
|
4016
|
+
const retVal = (output || [])
|
|
4730
4017
|
.filter((e) => e != null)
|
|
4731
4018
|
.map((entry) => {
|
|
4732
4019
|
if (entry === null) {
|
|
@@ -4734,6 +4021,7 @@ const deserializeAws_json1_1ClusterSummaryList = (output, context) => {
|
|
|
4734
4021
|
}
|
|
4735
4022
|
return deserializeAws_json1_1ClusterSummary(entry, context);
|
|
4736
4023
|
});
|
|
4024
|
+
return retVal;
|
|
4737
4025
|
};
|
|
4738
4026
|
const deserializeAws_json1_1ClusterTimeline = (output, context) => {
|
|
4739
4027
|
return {
|
|
@@ -4758,7 +4046,7 @@ const deserializeAws_json1_1Command = (output, context) => {
|
|
|
4758
4046
|
};
|
|
4759
4047
|
};
|
|
4760
4048
|
const deserializeAws_json1_1CommandList = (output, context) => {
|
|
4761
|
-
|
|
4049
|
+
const retVal = (output || [])
|
|
4762
4050
|
.filter((e) => e != null)
|
|
4763
4051
|
.map((entry) => {
|
|
4764
4052
|
if (entry === null) {
|
|
@@ -4766,6 +4054,7 @@ const deserializeAws_json1_1CommandList = (output, context) => {
|
|
|
4766
4054
|
}
|
|
4767
4055
|
return deserializeAws_json1_1Command(entry, context);
|
|
4768
4056
|
});
|
|
4057
|
+
return retVal;
|
|
4769
4058
|
};
|
|
4770
4059
|
const deserializeAws_json1_1ComputeLimits = (output, context) => {
|
|
4771
4060
|
return {
|
|
@@ -4788,7 +4077,7 @@ const deserializeAws_json1_1Configuration = (output, context) => {
|
|
|
4788
4077
|
};
|
|
4789
4078
|
};
|
|
4790
4079
|
const deserializeAws_json1_1ConfigurationList = (output, context) => {
|
|
4791
|
-
|
|
4080
|
+
const retVal = (output || [])
|
|
4792
4081
|
.filter((e) => e != null)
|
|
4793
4082
|
.map((entry) => {
|
|
4794
4083
|
if (entry === null) {
|
|
@@ -4796,6 +4085,7 @@ const deserializeAws_json1_1ConfigurationList = (output, context) => {
|
|
|
4796
4085
|
}
|
|
4797
4086
|
return deserializeAws_json1_1Configuration(entry, context);
|
|
4798
4087
|
});
|
|
4088
|
+
return retVal;
|
|
4799
4089
|
};
|
|
4800
4090
|
const deserializeAws_json1_1CreateSecurityConfigurationOutput = (output, context) => {
|
|
4801
4091
|
return {
|
|
@@ -4874,7 +4164,7 @@ const deserializeAws_json1_1EbsBlockDevice = (output, context) => {
|
|
|
4874
4164
|
};
|
|
4875
4165
|
};
|
|
4876
4166
|
const deserializeAws_json1_1EbsBlockDeviceList = (output, context) => {
|
|
4877
|
-
|
|
4167
|
+
const retVal = (output || [])
|
|
4878
4168
|
.filter((e) => e != null)
|
|
4879
4169
|
.map((entry) => {
|
|
4880
4170
|
if (entry === null) {
|
|
@@ -4882,6 +4172,7 @@ const deserializeAws_json1_1EbsBlockDeviceList = (output, context) => {
|
|
|
4882
4172
|
}
|
|
4883
4173
|
return deserializeAws_json1_1EbsBlockDevice(entry, context);
|
|
4884
4174
|
});
|
|
4175
|
+
return retVal;
|
|
4885
4176
|
};
|
|
4886
4177
|
const deserializeAws_json1_1EbsVolume = (output, context) => {
|
|
4887
4178
|
return {
|
|
@@ -4890,7 +4181,7 @@ const deserializeAws_json1_1EbsVolume = (output, context) => {
|
|
|
4890
4181
|
};
|
|
4891
4182
|
};
|
|
4892
4183
|
const deserializeAws_json1_1EbsVolumeList = (output, context) => {
|
|
4893
|
-
|
|
4184
|
+
const retVal = (output || [])
|
|
4894
4185
|
.filter((e) => e != null)
|
|
4895
4186
|
.map((entry) => {
|
|
4896
4187
|
if (entry === null) {
|
|
@@ -4898,6 +4189,7 @@ const deserializeAws_json1_1EbsVolumeList = (output, context) => {
|
|
|
4898
4189
|
}
|
|
4899
4190
|
return deserializeAws_json1_1EbsVolume(entry, context);
|
|
4900
4191
|
});
|
|
4192
|
+
return retVal;
|
|
4901
4193
|
};
|
|
4902
4194
|
const deserializeAws_json1_1Ec2InstanceAttributes = (output, context) => {
|
|
4903
4195
|
return {
|
|
@@ -4923,7 +4215,7 @@ const deserializeAws_json1_1Ec2InstanceAttributes = (output, context) => {
|
|
|
4923
4215
|
};
|
|
4924
4216
|
};
|
|
4925
4217
|
const deserializeAws_json1_1EC2InstanceIdsList = (output, context) => {
|
|
4926
|
-
|
|
4218
|
+
const retVal = (output || [])
|
|
4927
4219
|
.filter((e) => e != null)
|
|
4928
4220
|
.map((entry) => {
|
|
4929
4221
|
if (entry === null) {
|
|
@@ -4931,6 +4223,7 @@ const deserializeAws_json1_1EC2InstanceIdsList = (output, context) => {
|
|
|
4931
4223
|
}
|
|
4932
4224
|
return smithy_client_1.expectString(entry);
|
|
4933
4225
|
});
|
|
4226
|
+
return retVal;
|
|
4934
4227
|
};
|
|
4935
4228
|
const deserializeAws_json1_1ExecutionEngineConfig = (output, context) => {
|
|
4936
4229
|
return {
|
|
@@ -5043,7 +4336,7 @@ const deserializeAws_json1_1InstanceFleet = (output, context) => {
|
|
|
5043
4336
|
};
|
|
5044
4337
|
};
|
|
5045
4338
|
const deserializeAws_json1_1InstanceFleetList = (output, context) => {
|
|
5046
|
-
|
|
4339
|
+
const retVal = (output || [])
|
|
5047
4340
|
.filter((e) => e != null)
|
|
5048
4341
|
.map((entry) => {
|
|
5049
4342
|
if (entry === null) {
|
|
@@ -5051,6 +4344,7 @@ const deserializeAws_json1_1InstanceFleetList = (output, context) => {
|
|
|
5051
4344
|
}
|
|
5052
4345
|
return deserializeAws_json1_1InstanceFleet(entry, context);
|
|
5053
4346
|
});
|
|
4347
|
+
return retVal;
|
|
5054
4348
|
};
|
|
5055
4349
|
const deserializeAws_json1_1InstanceFleetProvisioningSpecifications = (output, context) => {
|
|
5056
4350
|
return {
|
|
@@ -5155,7 +4449,7 @@ const deserializeAws_json1_1InstanceGroupDetail = (output, context) => {
|
|
|
5155
4449
|
};
|
|
5156
4450
|
};
|
|
5157
4451
|
const deserializeAws_json1_1InstanceGroupDetailList = (output, context) => {
|
|
5158
|
-
|
|
4452
|
+
const retVal = (output || [])
|
|
5159
4453
|
.filter((e) => e != null)
|
|
5160
4454
|
.map((entry) => {
|
|
5161
4455
|
if (entry === null) {
|
|
@@ -5163,9 +4457,10 @@ const deserializeAws_json1_1InstanceGroupDetailList = (output, context) => {
|
|
|
5163
4457
|
}
|
|
5164
4458
|
return deserializeAws_json1_1InstanceGroupDetail(entry, context);
|
|
5165
4459
|
});
|
|
4460
|
+
return retVal;
|
|
5166
4461
|
};
|
|
5167
4462
|
const deserializeAws_json1_1InstanceGroupIdsList = (output, context) => {
|
|
5168
|
-
|
|
4463
|
+
const retVal = (output || [])
|
|
5169
4464
|
.filter((e) => e != null)
|
|
5170
4465
|
.map((entry) => {
|
|
5171
4466
|
if (entry === null) {
|
|
@@ -5173,9 +4468,10 @@ const deserializeAws_json1_1InstanceGroupIdsList = (output, context) => {
|
|
|
5173
4468
|
}
|
|
5174
4469
|
return smithy_client_1.expectString(entry);
|
|
5175
4470
|
});
|
|
4471
|
+
return retVal;
|
|
5176
4472
|
};
|
|
5177
4473
|
const deserializeAws_json1_1InstanceGroupList = (output, context) => {
|
|
5178
|
-
|
|
4474
|
+
const retVal = (output || [])
|
|
5179
4475
|
.filter((e) => e != null)
|
|
5180
4476
|
.map((entry) => {
|
|
5181
4477
|
if (entry === null) {
|
|
@@ -5183,6 +4479,7 @@ const deserializeAws_json1_1InstanceGroupList = (output, context) => {
|
|
|
5183
4479
|
}
|
|
5184
4480
|
return deserializeAws_json1_1InstanceGroup(entry, context);
|
|
5185
4481
|
});
|
|
4482
|
+
return retVal;
|
|
5186
4483
|
};
|
|
5187
4484
|
const deserializeAws_json1_1InstanceGroupStateChangeReason = (output, context) => {
|
|
5188
4485
|
return {
|
|
@@ -5215,7 +4512,7 @@ const deserializeAws_json1_1InstanceGroupTimeline = (output, context) => {
|
|
|
5215
4512
|
};
|
|
5216
4513
|
};
|
|
5217
4514
|
const deserializeAws_json1_1InstanceList = (output, context) => {
|
|
5218
|
-
|
|
4515
|
+
const retVal = (output || [])
|
|
5219
4516
|
.filter((e) => e != null)
|
|
5220
4517
|
.map((entry) => {
|
|
5221
4518
|
if (entry === null) {
|
|
@@ -5223,6 +4520,7 @@ const deserializeAws_json1_1InstanceList = (output, context) => {
|
|
|
5223
4520
|
}
|
|
5224
4521
|
return deserializeAws_json1_1Instance(entry, context);
|
|
5225
4522
|
});
|
|
4523
|
+
return retVal;
|
|
5226
4524
|
};
|
|
5227
4525
|
const deserializeAws_json1_1InstanceResizePolicy = (output, context) => {
|
|
5228
4526
|
return {
|
|
@@ -5282,7 +4580,7 @@ const deserializeAws_json1_1InstanceTypeSpecification = (output, context) => {
|
|
|
5282
4580
|
};
|
|
5283
4581
|
};
|
|
5284
4582
|
const deserializeAws_json1_1InstanceTypeSpecificationList = (output, context) => {
|
|
5285
|
-
|
|
4583
|
+
const retVal = (output || [])
|
|
5286
4584
|
.filter((e) => e != null)
|
|
5287
4585
|
.map((entry) => {
|
|
5288
4586
|
if (entry === null) {
|
|
@@ -5290,6 +4588,7 @@ const deserializeAws_json1_1InstanceTypeSpecificationList = (output, context) =>
|
|
|
5290
4588
|
}
|
|
5291
4589
|
return deserializeAws_json1_1InstanceTypeSpecification(entry, context);
|
|
5292
4590
|
});
|
|
4591
|
+
return retVal;
|
|
5293
4592
|
};
|
|
5294
4593
|
const deserializeAws_json1_1InternalServerError = (output, context) => {
|
|
5295
4594
|
return {};
|
|
@@ -5335,7 +4634,7 @@ const deserializeAws_json1_1JobFlowDetail = (output, context) => {
|
|
|
5335
4634
|
};
|
|
5336
4635
|
};
|
|
5337
4636
|
const deserializeAws_json1_1JobFlowDetailList = (output, context) => {
|
|
5338
|
-
|
|
4637
|
+
const retVal = (output || [])
|
|
5339
4638
|
.filter((e) => e != null)
|
|
5340
4639
|
.map((entry) => {
|
|
5341
4640
|
if (entry === null) {
|
|
@@ -5343,6 +4642,7 @@ const deserializeAws_json1_1JobFlowDetailList = (output, context) => {
|
|
|
5343
4642
|
}
|
|
5344
4643
|
return deserializeAws_json1_1JobFlowDetail(entry, context);
|
|
5345
4644
|
});
|
|
4645
|
+
return retVal;
|
|
5346
4646
|
};
|
|
5347
4647
|
const deserializeAws_json1_1JobFlowExecutionStatusDetail = (output, context) => {
|
|
5348
4648
|
return {
|
|
@@ -5399,7 +4699,7 @@ const deserializeAws_json1_1KeyValue = (output, context) => {
|
|
|
5399
4699
|
};
|
|
5400
4700
|
};
|
|
5401
4701
|
const deserializeAws_json1_1KeyValueList = (output, context) => {
|
|
5402
|
-
|
|
4702
|
+
const retVal = (output || [])
|
|
5403
4703
|
.filter((e) => e != null)
|
|
5404
4704
|
.map((entry) => {
|
|
5405
4705
|
if (entry === null) {
|
|
@@ -5407,6 +4707,7 @@ const deserializeAws_json1_1KeyValueList = (output, context) => {
|
|
|
5407
4707
|
}
|
|
5408
4708
|
return deserializeAws_json1_1KeyValue(entry, context);
|
|
5409
4709
|
});
|
|
4710
|
+
return retVal;
|
|
5410
4711
|
};
|
|
5411
4712
|
const deserializeAws_json1_1ListBootstrapActionsOutput = (output, context) => {
|
|
5412
4713
|
return {
|
|
@@ -5510,7 +4811,7 @@ const deserializeAws_json1_1MetricDimension = (output, context) => {
|
|
|
5510
4811
|
};
|
|
5511
4812
|
};
|
|
5512
4813
|
const deserializeAws_json1_1MetricDimensionList = (output, context) => {
|
|
5513
|
-
|
|
4814
|
+
const retVal = (output || [])
|
|
5514
4815
|
.filter((e) => e != null)
|
|
5515
4816
|
.map((entry) => {
|
|
5516
4817
|
if (entry === null) {
|
|
@@ -5518,6 +4819,7 @@ const deserializeAws_json1_1MetricDimensionList = (output, context) => {
|
|
|
5518
4819
|
}
|
|
5519
4820
|
return deserializeAws_json1_1MetricDimension(entry, context);
|
|
5520
4821
|
});
|
|
4822
|
+
return retVal;
|
|
5521
4823
|
};
|
|
5522
4824
|
const deserializeAws_json1_1ModifyClusterOutput = (output, context) => {
|
|
5523
4825
|
return {
|
|
@@ -5564,7 +4866,7 @@ const deserializeAws_json1_1NotebookExecutionSummary = (output, context) => {
|
|
|
5564
4866
|
};
|
|
5565
4867
|
};
|
|
5566
4868
|
const deserializeAws_json1_1NotebookExecutionSummaryList = (output, context) => {
|
|
5567
|
-
|
|
4869
|
+
const retVal = (output || [])
|
|
5568
4870
|
.filter((e) => e != null)
|
|
5569
4871
|
.map((entry) => {
|
|
5570
4872
|
if (entry === null) {
|
|
@@ -5572,6 +4874,7 @@ const deserializeAws_json1_1NotebookExecutionSummaryList = (output, context) =>
|
|
|
5572
4874
|
}
|
|
5573
4875
|
return deserializeAws_json1_1NotebookExecutionSummary(entry, context);
|
|
5574
4876
|
});
|
|
4877
|
+
return retVal;
|
|
5575
4878
|
};
|
|
5576
4879
|
const deserializeAws_json1_1OnDemandCapacityReservationOptions = (output, context) => {
|
|
5577
4880
|
return {
|
|
@@ -5595,7 +4898,7 @@ const deserializeAws_json1_1PlacementGroupConfig = (output, context) => {
|
|
|
5595
4898
|
};
|
|
5596
4899
|
};
|
|
5597
4900
|
const deserializeAws_json1_1PlacementGroupConfigList = (output, context) => {
|
|
5598
|
-
|
|
4901
|
+
const retVal = (output || [])
|
|
5599
4902
|
.filter((e) => e != null)
|
|
5600
4903
|
.map((entry) => {
|
|
5601
4904
|
if (entry === null) {
|
|
@@ -5603,6 +4906,7 @@ const deserializeAws_json1_1PlacementGroupConfigList = (output, context) => {
|
|
|
5603
4906
|
}
|
|
5604
4907
|
return deserializeAws_json1_1PlacementGroupConfig(entry, context);
|
|
5605
4908
|
});
|
|
4909
|
+
return retVal;
|
|
5606
4910
|
};
|
|
5607
4911
|
const deserializeAws_json1_1PlacementType = (output, context) => {
|
|
5608
4912
|
return {
|
|
@@ -5619,7 +4923,7 @@ const deserializeAws_json1_1PortRange = (output, context) => {
|
|
|
5619
4923
|
};
|
|
5620
4924
|
};
|
|
5621
4925
|
const deserializeAws_json1_1PortRanges = (output, context) => {
|
|
5622
|
-
|
|
4926
|
+
const retVal = (output || [])
|
|
5623
4927
|
.filter((e) => e != null)
|
|
5624
4928
|
.map((entry) => {
|
|
5625
4929
|
if (entry === null) {
|
|
@@ -5627,6 +4931,7 @@ const deserializeAws_json1_1PortRanges = (output, context) => {
|
|
|
5627
4931
|
}
|
|
5628
4932
|
return deserializeAws_json1_1PortRange(entry, context);
|
|
5629
4933
|
});
|
|
4934
|
+
return retVal;
|
|
5630
4935
|
};
|
|
5631
4936
|
const deserializeAws_json1_1PutAutoScalingPolicyOutput = (output, context) => {
|
|
5632
4937
|
return {
|
|
@@ -5692,7 +4997,7 @@ const deserializeAws_json1_1ScalingRule = (output, context) => {
|
|
|
5692
4997
|
};
|
|
5693
4998
|
};
|
|
5694
4999
|
const deserializeAws_json1_1ScalingRuleList = (output, context) => {
|
|
5695
|
-
|
|
5000
|
+
const retVal = (output || [])
|
|
5696
5001
|
.filter((e) => e != null)
|
|
5697
5002
|
.map((entry) => {
|
|
5698
5003
|
if (entry === null) {
|
|
@@ -5700,6 +5005,7 @@ const deserializeAws_json1_1ScalingRuleList = (output, context) => {
|
|
|
5700
5005
|
}
|
|
5701
5006
|
return deserializeAws_json1_1ScalingRule(entry, context);
|
|
5702
5007
|
});
|
|
5008
|
+
return retVal;
|
|
5703
5009
|
};
|
|
5704
5010
|
const deserializeAws_json1_1ScalingTrigger = (output, context) => {
|
|
5705
5011
|
return {
|
|
@@ -5717,7 +5023,7 @@ const deserializeAws_json1_1ScriptBootstrapActionConfig = (output, context) => {
|
|
|
5717
5023
|
};
|
|
5718
5024
|
};
|
|
5719
5025
|
const deserializeAws_json1_1SecurityConfigurationList = (output, context) => {
|
|
5720
|
-
|
|
5026
|
+
const retVal = (output || [])
|
|
5721
5027
|
.filter((e) => e != null)
|
|
5722
5028
|
.map((entry) => {
|
|
5723
5029
|
if (entry === null) {
|
|
@@ -5725,6 +5031,7 @@ const deserializeAws_json1_1SecurityConfigurationList = (output, context) => {
|
|
|
5725
5031
|
}
|
|
5726
5032
|
return deserializeAws_json1_1SecurityConfigurationSummary(entry, context);
|
|
5727
5033
|
});
|
|
5034
|
+
return retVal;
|
|
5728
5035
|
};
|
|
5729
5036
|
const deserializeAws_json1_1SecurityConfigurationSummary = (output, context) => {
|
|
5730
5037
|
return {
|
|
@@ -5762,7 +5069,7 @@ const deserializeAws_json1_1SessionMappingSummary = (output, context) => {
|
|
|
5762
5069
|
};
|
|
5763
5070
|
};
|
|
5764
5071
|
const deserializeAws_json1_1SessionMappingSummaryList = (output, context) => {
|
|
5765
|
-
|
|
5072
|
+
const retVal = (output || [])
|
|
5766
5073
|
.filter((e) => e != null)
|
|
5767
5074
|
.map((entry) => {
|
|
5768
5075
|
if (entry === null) {
|
|
@@ -5770,6 +5077,7 @@ const deserializeAws_json1_1SessionMappingSummaryList = (output, context) => {
|
|
|
5770
5077
|
}
|
|
5771
5078
|
return deserializeAws_json1_1SessionMappingSummary(entry, context);
|
|
5772
5079
|
});
|
|
5080
|
+
return retVal;
|
|
5773
5081
|
};
|
|
5774
5082
|
const deserializeAws_json1_1ShrinkPolicy = (output, context) => {
|
|
5775
5083
|
return {
|
|
@@ -5793,7 +5101,7 @@ const deserializeAws_json1_1SimplifiedApplication = (output, context) => {
|
|
|
5793
5101
|
};
|
|
5794
5102
|
};
|
|
5795
5103
|
const deserializeAws_json1_1SimplifiedApplicationList = (output, context) => {
|
|
5796
|
-
|
|
5104
|
+
const retVal = (output || [])
|
|
5797
5105
|
.filter((e) => e != null)
|
|
5798
5106
|
.map((entry) => {
|
|
5799
5107
|
if (entry === null) {
|
|
@@ -5801,6 +5109,7 @@ const deserializeAws_json1_1SimplifiedApplicationList = (output, context) => {
|
|
|
5801
5109
|
}
|
|
5802
5110
|
return deserializeAws_json1_1SimplifiedApplication(entry, context);
|
|
5803
5111
|
});
|
|
5112
|
+
return retVal;
|
|
5804
5113
|
};
|
|
5805
5114
|
const deserializeAws_json1_1SpotProvisioningSpecification = (output, context) => {
|
|
5806
5115
|
return {
|
|
@@ -5848,7 +5157,7 @@ const deserializeAws_json1_1StepDetail = (output, context) => {
|
|
|
5848
5157
|
};
|
|
5849
5158
|
};
|
|
5850
5159
|
const deserializeAws_json1_1StepDetailList = (output, context) => {
|
|
5851
|
-
|
|
5160
|
+
const retVal = (output || [])
|
|
5852
5161
|
.filter((e) => e != null)
|
|
5853
5162
|
.map((entry) => {
|
|
5854
5163
|
if (entry === null) {
|
|
@@ -5856,6 +5165,7 @@ const deserializeAws_json1_1StepDetailList = (output, context) => {
|
|
|
5856
5165
|
}
|
|
5857
5166
|
return deserializeAws_json1_1StepDetail(entry, context);
|
|
5858
5167
|
});
|
|
5168
|
+
return retVal;
|
|
5859
5169
|
};
|
|
5860
5170
|
const deserializeAws_json1_1StepExecutionStatusDetail = (output, context) => {
|
|
5861
5171
|
return {
|
|
@@ -5873,7 +5183,7 @@ const deserializeAws_json1_1StepExecutionStatusDetail = (output, context) => {
|
|
|
5873
5183
|
};
|
|
5874
5184
|
};
|
|
5875
5185
|
const deserializeAws_json1_1StepIdsList = (output, context) => {
|
|
5876
|
-
|
|
5186
|
+
const retVal = (output || [])
|
|
5877
5187
|
.filter((e) => e != null)
|
|
5878
5188
|
.map((entry) => {
|
|
5879
5189
|
if (entry === null) {
|
|
@@ -5881,6 +5191,7 @@ const deserializeAws_json1_1StepIdsList = (output, context) => {
|
|
|
5881
5191
|
}
|
|
5882
5192
|
return smithy_client_1.expectString(entry);
|
|
5883
5193
|
});
|
|
5194
|
+
return retVal;
|
|
5884
5195
|
};
|
|
5885
5196
|
const deserializeAws_json1_1StepStateChangeReason = (output, context) => {
|
|
5886
5197
|
return {
|
|
@@ -5916,7 +5227,7 @@ const deserializeAws_json1_1StepSummary = (output, context) => {
|
|
|
5916
5227
|
};
|
|
5917
5228
|
};
|
|
5918
5229
|
const deserializeAws_json1_1StepSummaryList = (output, context) => {
|
|
5919
|
-
|
|
5230
|
+
const retVal = (output || [])
|
|
5920
5231
|
.filter((e) => e != null)
|
|
5921
5232
|
.map((entry) => {
|
|
5922
5233
|
if (entry === null) {
|
|
@@ -5924,6 +5235,7 @@ const deserializeAws_json1_1StepSummaryList = (output, context) => {
|
|
|
5924
5235
|
}
|
|
5925
5236
|
return deserializeAws_json1_1StepSummary(entry, context);
|
|
5926
5237
|
});
|
|
5238
|
+
return retVal;
|
|
5927
5239
|
};
|
|
5928
5240
|
const deserializeAws_json1_1StepTimeline = (output, context) => {
|
|
5929
5241
|
return {
|
|
@@ -5939,7 +5251,7 @@ const deserializeAws_json1_1StepTimeline = (output, context) => {
|
|
|
5939
5251
|
};
|
|
5940
5252
|
};
|
|
5941
5253
|
const deserializeAws_json1_1StringList = (output, context) => {
|
|
5942
|
-
|
|
5254
|
+
const retVal = (output || [])
|
|
5943
5255
|
.filter((e) => e != null)
|
|
5944
5256
|
.map((entry) => {
|
|
5945
5257
|
if (entry === null) {
|
|
@@ -5947,6 +5259,7 @@ const deserializeAws_json1_1StringList = (output, context) => {
|
|
|
5947
5259
|
}
|
|
5948
5260
|
return smithy_client_1.expectString(entry);
|
|
5949
5261
|
});
|
|
5262
|
+
return retVal;
|
|
5950
5263
|
};
|
|
5951
5264
|
const deserializeAws_json1_1StringMap = (output, context) => {
|
|
5952
5265
|
return Object.entries(output).reduce((acc, [key, value]) => {
|
|
@@ -6000,7 +5313,7 @@ const deserializeAws_json1_1StudioSummary = (output, context) => {
|
|
|
6000
5313
|
};
|
|
6001
5314
|
};
|
|
6002
5315
|
const deserializeAws_json1_1StudioSummaryList = (output, context) => {
|
|
6003
|
-
|
|
5316
|
+
const retVal = (output || [])
|
|
6004
5317
|
.filter((e) => e != null)
|
|
6005
5318
|
.map((entry) => {
|
|
6006
5319
|
if (entry === null) {
|
|
@@ -6008,9 +5321,10 @@ const deserializeAws_json1_1StudioSummaryList = (output, context) => {
|
|
|
6008
5321
|
}
|
|
6009
5322
|
return deserializeAws_json1_1StudioSummary(entry, context);
|
|
6010
5323
|
});
|
|
5324
|
+
return retVal;
|
|
6011
5325
|
};
|
|
6012
5326
|
const deserializeAws_json1_1SubnetIdList = (output, context) => {
|
|
6013
|
-
|
|
5327
|
+
const retVal = (output || [])
|
|
6014
5328
|
.filter((e) => e != null)
|
|
6015
5329
|
.map((entry) => {
|
|
6016
5330
|
if (entry === null) {
|
|
@@ -6018,9 +5332,10 @@ const deserializeAws_json1_1SubnetIdList = (output, context) => {
|
|
|
6018
5332
|
}
|
|
6019
5333
|
return smithy_client_1.expectString(entry);
|
|
6020
5334
|
});
|
|
5335
|
+
return retVal;
|
|
6021
5336
|
};
|
|
6022
5337
|
const deserializeAws_json1_1SupportedProductsList = (output, context) => {
|
|
6023
|
-
|
|
5338
|
+
const retVal = (output || [])
|
|
6024
5339
|
.filter((e) => e != null)
|
|
6025
5340
|
.map((entry) => {
|
|
6026
5341
|
if (entry === null) {
|
|
@@ -6028,6 +5343,7 @@ const deserializeAws_json1_1SupportedProductsList = (output, context) => {
|
|
|
6028
5343
|
}
|
|
6029
5344
|
return smithy_client_1.expectString(entry);
|
|
6030
5345
|
});
|
|
5346
|
+
return retVal;
|
|
6031
5347
|
};
|
|
6032
5348
|
const deserializeAws_json1_1Tag = (output, context) => {
|
|
6033
5349
|
return {
|
|
@@ -6036,7 +5352,7 @@ const deserializeAws_json1_1Tag = (output, context) => {
|
|
|
6036
5352
|
};
|
|
6037
5353
|
};
|
|
6038
5354
|
const deserializeAws_json1_1TagList = (output, context) => {
|
|
6039
|
-
|
|
5355
|
+
const retVal = (output || [])
|
|
6040
5356
|
.filter((e) => e != null)
|
|
6041
5357
|
.map((entry) => {
|
|
6042
5358
|
if (entry === null) {
|
|
@@ -6044,6 +5360,7 @@ const deserializeAws_json1_1TagList = (output, context) => {
|
|
|
6044
5360
|
}
|
|
6045
5361
|
return deserializeAws_json1_1Tag(entry, context);
|
|
6046
5362
|
});
|
|
5363
|
+
return retVal;
|
|
6047
5364
|
};
|
|
6048
5365
|
const deserializeAws_json1_1VolumeSpecification = (output, context) => {
|
|
6049
5366
|
return {
|
|
@@ -6053,7 +5370,7 @@ const deserializeAws_json1_1VolumeSpecification = (output, context) => {
|
|
|
6053
5370
|
};
|
|
6054
5371
|
};
|
|
6055
5372
|
const deserializeAws_json1_1XmlStringList = (output, context) => {
|
|
6056
|
-
|
|
5373
|
+
const retVal = (output || [])
|
|
6057
5374
|
.filter((e) => e != null)
|
|
6058
5375
|
.map((entry) => {
|
|
6059
5376
|
if (entry === null) {
|
|
@@ -6061,9 +5378,10 @@ const deserializeAws_json1_1XmlStringList = (output, context) => {
|
|
|
6061
5378
|
}
|
|
6062
5379
|
return smithy_client_1.expectString(entry);
|
|
6063
5380
|
});
|
|
5381
|
+
return retVal;
|
|
6064
5382
|
};
|
|
6065
5383
|
const deserializeAws_json1_1XmlStringMaxLen256List = (output, context) => {
|
|
6066
|
-
|
|
5384
|
+
const retVal = (output || [])
|
|
6067
5385
|
.filter((e) => e != null)
|
|
6068
5386
|
.map((entry) => {
|
|
6069
5387
|
if (entry === null) {
|
|
@@ -6071,6 +5389,7 @@ const deserializeAws_json1_1XmlStringMaxLen256List = (output, context) => {
|
|
|
6071
5389
|
}
|
|
6072
5390
|
return smithy_client_1.expectString(entry);
|
|
6073
5391
|
});
|
|
5392
|
+
return retVal;
|
|
6074
5393
|
};
|
|
6075
5394
|
const deserializeMetadata = (output) => {
|
|
6076
5395
|
var _a;
|