@aws-sdk/client-cloudformation 3.52.0 → 3.54.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (24) hide show
  1. package/CHANGELOG.md +27 -0
  2. package/dist-cjs/index.js +3 -0
  3. package/dist-cjs/models/CloudFormationServiceException.js +11 -0
  4. package/dist-cjs/models/models_0.js +314 -5
  5. package/dist-cjs/protocols/Aws_query.js +431 -1364
  6. package/dist-es/index.js +1 -0
  7. package/dist-es/models/CloudFormationServiceException.js +12 -0
  8. package/dist-es/models/models_0.js +288 -1
  9. package/dist-es/protocols/Aws_query.js +975 -1438
  10. package/dist-types/CloudFormationClient.d.ts +2 -2
  11. package/dist-types/index.d.ts +1 -0
  12. package/dist-types/models/CloudFormationServiceException.d.ts +10 -0
  13. package/dist-types/models/models_0.d.ts +156 -67
  14. package/dist-types/runtimeConfig.browser.d.ts +1 -1
  15. package/dist-types/runtimeConfig.d.ts +1 -1
  16. package/dist-types/runtimeConfig.native.d.ts +1 -1
  17. package/dist-types/ts3.4/CloudFormationClient.d.ts +2 -2
  18. package/dist-types/ts3.4/index.d.ts +1 -0
  19. package/dist-types/ts3.4/models/CloudFormationServiceException.d.ts +6 -0
  20. package/dist-types/ts3.4/models/models_0.d.ts +112 -67
  21. package/dist-types/ts3.4/runtimeConfig.browser.d.ts +1 -1
  22. package/dist-types/ts3.4/runtimeConfig.d.ts +1 -1
  23. package/dist-types/ts3.4/runtimeConfig.native.d.ts +1 -1
  24. package/package.json +28 -28
package/dist-es/protocols/Aws_query.js CHANGED
@@ -1,9 +1,11 @@
1
1
  import { __assign, __awaiter, __generator, __read, __values } from "tslib";
2
2
  import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
3
- import { expectNonNull as __expectNonNull, expectString as __expectString, extendedEncodeURIComponent as __extendedEncodeURIComponent, getArrayIfSingleItem as __getArrayIfSingleItem, getValueFromTextNode as __getValueFromTextNode, parseBoolean as __parseBoolean, parseRfc3339DateTime as __parseRfc3339DateTime, strictParseInt32 as __strictParseInt32, } from "@aws-sdk/smithy-client";
3
+ import { decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectString as __expectString, extendedEncodeURIComponent as __extendedEncodeURIComponent, getArrayIfSingleItem as __getArrayIfSingleItem, getValueFromTextNode as __getValueFromTextNode, parseBoolean as __parseBoolean, parseRfc3339DateTime as __parseRfc3339DateTime, strictParseInt32 as __strictParseInt32, } from "@aws-sdk/smithy-client";
4
4
  import { decodeHTML } from "entities";
5
5
  import { parse as xmlParse } from "fast-xml-parser";
6
6
  import { v4 as generateIdempotencyToken } from "uuid";
7
+ import { CloudFormationServiceException as __BaseException } from "../models/CloudFormationServiceException";
8
+ import { AlreadyExistsException, CFNRegistryException, ChangeSetNotFoundException, CreatedButModifiedException, InsufficientCapabilitiesException, InvalidChangeSetStatusException, InvalidOperationException, InvalidStateTransitionException, LimitExceededException, NameAlreadyExistsException, OperationIdAlreadyExistsException, OperationInProgressException, OperationNotFoundException, OperationStatusCheckFailedException, StackInstanceNotFoundException, StackNotFoundException, StackSetNotEmptyException, StackSetNotFoundException, StaleRequestException, TokenAlreadyExistsException, TypeConfigurationNotFoundException, TypeNotFoundException, } from "../models/models_0";
7
9
  export var serializeAws_queryActivateTypeCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
8
10
  var headers, body;
9
11
  return __generator(this, function (_a) {
@@ -683,16 +685,16 @@ export var deserializeAws_queryActivateTypeCommand = function (output, context)
683
685
  });
684
686
  }); };
685
687
  var deserializeAws_queryActivateTypeCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
686
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
687
- var _e;
688
- return __generator(this, function (_f) {
689
- switch (_f.label) {
688
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
689
+ var _c;
690
+ return __generator(this, function (_d) {
691
+ switch (_d.label) {
690
692
  case 0:
691
693
  _a = [__assign({}, output)];
692
- _e = {};
694
+ _c = {};
693
695
  return [4, parseBody(output.body, context)];
694
696
  case 1:
695
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
697
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
696
698
  errorCode = "UnknownError";
697
699
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
698
700
  _b = errorCode;
@@ -703,28 +705,18 @@ var deserializeAws_queryActivateTypeCommandError = function (output, context) {
703
705
  case "com.amazonaws.cloudformation#TypeNotFoundException": return [3, 4];
704
706
  }
705
707
  return [3, 6];
706
- case 2:
707
- _c = [{}];
708
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
709
- case 3:
710
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
711
- return [3, 7];
712
- case 4:
713
- _d = [{}];
714
- return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
715
- case 5:
716
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
717
- return [3, 7];
708
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
709
+ case 3: throw _d.sent();
710
+ case 4: return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
711
+ case 5: throw _d.sent();
718
712
  case 6:
719
713
  parsedBody = parsedOutput.body;
720
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
721
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
722
- _f.label = 7;
723
- case 7:
724
- message = response.message || response.Message || errorCode;
725
- response.message = message;
726
- delete response.Message;
727
- return [2, Promise.reject(Object.assign(new Error(message), response))];
714
+ response = new __BaseException({
715
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
716
+ $fault: "client",
717
+ $metadata: deserializeMetadata(output),
718
+ });
719
+ throw __decorateServiceException(response, parsedBody.Error);
728
720
  }
729
721
  });
730
722
  }); };
@@ -747,16 +739,16 @@ export var deserializeAws_queryBatchDescribeTypeConfigurationsCommand = function
747
739
  });
748
740
  }); };
749
741
  var deserializeAws_queryBatchDescribeTypeConfigurationsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
750
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
751
- var _e;
752
- return __generator(this, function (_f) {
753
- switch (_f.label) {
742
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
743
+ var _c;
744
+ return __generator(this, function (_d) {
745
+ switch (_d.label) {
754
746
  case 0:
755
747
  _a = [__assign({}, output)];
756
- _e = {};
748
+ _c = {};
757
749
  return [4, parseBody(output.body, context)];
758
750
  case 1:
759
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
751
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
760
752
  errorCode = "UnknownError";
761
753
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
762
754
  _b = errorCode;
@@ -767,28 +759,18 @@ var deserializeAws_queryBatchDescribeTypeConfigurationsCommandError = function (
767
759
  case "com.amazonaws.cloudformation#TypeConfigurationNotFoundException": return [3, 4];
768
760
  }
769
761
  return [3, 6];
770
- case 2:
771
- _c = [{}];
772
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
773
- case 3:
774
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
775
- return [3, 7];
776
- case 4:
777
- _d = [{}];
778
- return [4, deserializeAws_queryTypeConfigurationNotFoundExceptionResponse(parsedOutput, context)];
779
- case 5:
780
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
781
- return [3, 7];
762
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
763
+ case 3: throw _d.sent();
764
+ case 4: return [4, deserializeAws_queryTypeConfigurationNotFoundExceptionResponse(parsedOutput, context)];
765
+ case 5: throw _d.sent();
782
766
  case 6:
783
767
  parsedBody = parsedOutput.body;
784
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
785
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
786
- _f.label = 7;
787
- case 7:
788
- message = response.message || response.Message || errorCode;
789
- response.message = message;
790
- delete response.Message;
791
- return [2, Promise.reject(Object.assign(new Error(message), response))];
768
+ response = new __BaseException({
769
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
770
+ $fault: "client",
771
+ $metadata: deserializeMetadata(output),
772
+ });
773
+ throw __decorateServiceException(response, parsedBody.Error);
792
774
  }
793
775
  });
794
776
  }); };
@@ -811,16 +793,16 @@ export var deserializeAws_queryCancelUpdateStackCommand = function (output, cont
811
793
  });
812
794
  }); };
813
795
  var deserializeAws_queryCancelUpdateStackCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
814
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
815
- var _d;
816
- return __generator(this, function (_e) {
817
- switch (_e.label) {
796
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
797
+ var _c;
798
+ return __generator(this, function (_d) {
799
+ switch (_d.label) {
818
800
  case 0:
819
801
  _a = [__assign({}, output)];
820
- _d = {};
802
+ _c = {};
821
803
  return [4, parseBody(output.body, context)];
822
804
  case 1:
823
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
805
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
824
806
  errorCode = "UnknownError";
825
807
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
826
808
  _b = errorCode;
@@ -829,22 +811,16 @@ var deserializeAws_queryCancelUpdateStackCommandError = function (output, contex
829
811
  case "com.amazonaws.cloudformation#TokenAlreadyExistsException": return [3, 2];
830
812
  }
831
813
  return [3, 4];
832
- case 2:
833
- _c = [{}];
834
- return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
835
- case 3:
836
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
837
- return [3, 5];
814
+ case 2: return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
815
+ case 3: throw _d.sent();
838
816
  case 4:
839
817
  parsedBody = parsedOutput.body;
840
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
841
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
842
- _e.label = 5;
843
- case 5:
844
- message = response.message || response.Message || errorCode;
845
- response.message = message;
846
- delete response.Message;
847
- return [2, Promise.reject(Object.assign(new Error(message), response))];
818
+ response = new __BaseException({
819
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
820
+ $fault: "client",
821
+ $metadata: deserializeMetadata(output),
822
+ });
823
+ throw __decorateServiceException(response, parsedBody.Error);
848
824
  }
849
825
  });
850
826
  }); };
@@ -867,16 +843,16 @@ export var deserializeAws_queryContinueUpdateRollbackCommand = function (output,
867
843
  });
868
844
  }); };
869
845
  var deserializeAws_queryContinueUpdateRollbackCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
870
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
871
- var _d;
872
- return __generator(this, function (_e) {
873
- switch (_e.label) {
846
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
847
+ var _c;
848
+ return __generator(this, function (_d) {
849
+ switch (_d.label) {
874
850
  case 0:
875
851
  _a = [__assign({}, output)];
876
- _d = {};
852
+ _c = {};
877
853
  return [4, parseBody(output.body, context)];
878
854
  case 1:
879
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
855
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
880
856
  errorCode = "UnknownError";
881
857
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
882
858
  _b = errorCode;
@@ -885,22 +861,16 @@ var deserializeAws_queryContinueUpdateRollbackCommandError = function (output, c
885
861
  case "com.amazonaws.cloudformation#TokenAlreadyExistsException": return [3, 2];
886
862
  }
887
863
  return [3, 4];
888
- case 2:
889
- _c = [{}];
890
- return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
891
- case 3:
892
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
893
- return [3, 5];
864
+ case 2: return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
865
+ case 3: throw _d.sent();
894
866
  case 4:
895
867
  parsedBody = parsedOutput.body;
896
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
897
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
898
- _e.label = 5;
899
- case 5:
900
- message = response.message || response.Message || errorCode;
901
- response.message = message;
902
- delete response.Message;
903
- return [2, Promise.reject(Object.assign(new Error(message), response))];
868
+ response = new __BaseException({
869
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
870
+ $fault: "client",
871
+ $metadata: deserializeMetadata(output),
872
+ });
873
+ throw __decorateServiceException(response, parsedBody.Error);
904
874
  }
905
875
  });
906
876
  }); };
@@ -923,16 +893,16 @@ export var deserializeAws_queryCreateChangeSetCommand = function (output, contex
923
893
  });
924
894
  }); };
925
895
  var deserializeAws_queryCreateChangeSetCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
926
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
927
- var _f;
928
- return __generator(this, function (_g) {
929
- switch (_g.label) {
896
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
897
+ var _c;
898
+ return __generator(this, function (_d) {
899
+ switch (_d.label) {
930
900
  case 0:
931
901
  _a = [__assign({}, output)];
932
- _f = {};
902
+ _c = {};
933
903
  return [4, parseBody(output.body, context)];
934
904
  case 1:
935
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
905
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
936
906
  errorCode = "UnknownError";
937
907
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
938
908
  _b = errorCode;
@@ -945,34 +915,20 @@ var deserializeAws_queryCreateChangeSetCommandError = function (output, context)
945
915
  case "com.amazonaws.cloudformation#LimitExceededException": return [3, 6];
946
916
  }
947
917
  return [3, 8];
948
- case 2:
949
- _c = [{}];
950
- return [4, deserializeAws_queryAlreadyExistsExceptionResponse(parsedOutput, context)];
951
- case 3:
952
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
953
- return [3, 9];
954
- case 4:
955
- _d = [{}];
956
- return [4, deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)];
957
- case 5:
958
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
959
- return [3, 9];
960
- case 6:
961
- _e = [{}];
962
- return [4, deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)];
963
- case 7:
964
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
965
- return [3, 9];
918
+ case 2: return [4, deserializeAws_queryAlreadyExistsExceptionResponse(parsedOutput, context)];
919
+ case 3: throw _d.sent();
920
+ case 4: return [4, deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)];
921
+ case 5: throw _d.sent();
922
+ case 6: return [4, deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)];
923
+ case 7: throw _d.sent();
966
924
  case 8:
967
925
  parsedBody = parsedOutput.body;
968
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
969
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
970
- _g.label = 9;
971
- case 9:
972
- message = response.message || response.Message || errorCode;
973
- response.message = message;
974
- delete response.Message;
975
- return [2, Promise.reject(Object.assign(new Error(message), response))];
926
+ response = new __BaseException({
927
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
928
+ $fault: "client",
929
+ $metadata: deserializeMetadata(output),
930
+ });
931
+ throw __decorateServiceException(response, parsedBody.Error);
976
932
  }
977
933
  });
978
934
  }); };
@@ -995,16 +951,16 @@ export var deserializeAws_queryCreateStackCommand = function (output, context) {
995
951
  });
996
952
  }); };
997
953
  var deserializeAws_queryCreateStackCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
998
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
999
- var _g;
1000
- return __generator(this, function (_h) {
1001
- switch (_h.label) {
954
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
955
+ var _c;
956
+ return __generator(this, function (_d) {
957
+ switch (_d.label) {
1002
958
  case 0:
1003
959
  _a = [__assign({}, output)];
1004
- _g = {};
960
+ _c = {};
1005
961
  return [4, parseBody(output.body, context)];
1006
962
  case 1:
1007
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
963
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1008
964
  errorCode = "UnknownError";
1009
965
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1010
966
  _b = errorCode;
@@ -1019,40 +975,22 @@ var deserializeAws_queryCreateStackCommandError = function (output, context) { r
1019
975
  case "com.amazonaws.cloudformation#TokenAlreadyExistsException": return [3, 8];
1020
976
  }
1021
977
  return [3, 10];
1022
- case 2:
1023
- _c = [{}];
1024
- return [4, deserializeAws_queryAlreadyExistsExceptionResponse(parsedOutput, context)];
1025
- case 3:
1026
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1027
- return [3, 11];
1028
- case 4:
1029
- _d = [{}];
1030
- return [4, deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)];
1031
- case 5:
1032
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1033
- return [3, 11];
1034
- case 6:
1035
- _e = [{}];
1036
- return [4, deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)];
1037
- case 7:
1038
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1039
- return [3, 11];
1040
- case 8:
1041
- _f = [{}];
1042
- return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
1043
- case 9:
1044
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1045
- return [3, 11];
978
+ case 2: return [4, deserializeAws_queryAlreadyExistsExceptionResponse(parsedOutput, context)];
979
+ case 3: throw _d.sent();
980
+ case 4: return [4, deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)];
981
+ case 5: throw _d.sent();
982
+ case 6: return [4, deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)];
983
+ case 7: throw _d.sent();
984
+ case 8: return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
985
+ case 9: throw _d.sent();
1046
986
  case 10:
1047
987
  parsedBody = parsedOutput.body;
1048
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1049
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1050
- _h.label = 11;
1051
- case 11:
1052
- message = response.message || response.Message || errorCode;
1053
- response.message = message;
1054
- delete response.Message;
1055
- return [2, Promise.reject(Object.assign(new Error(message), response))];
988
+ response = new __BaseException({
989
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
990
+ $fault: "client",
991
+ $metadata: deserializeMetadata(output),
992
+ });
993
+ throw __decorateServiceException(response, parsedBody.Error);
1056
994
  }
1057
995
  });
1058
996
  }); };
@@ -1075,16 +1013,16 @@ export var deserializeAws_queryCreateStackInstancesCommand = function (output, c
1075
1013
  });
1076
1014
  }); };
1077
1015
  var deserializeAws_queryCreateStackInstancesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1078
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, _h, parsedBody, message;
1079
- var _j;
1080
- return __generator(this, function (_k) {
1081
- switch (_k.label) {
1016
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1017
+ var _c;
1018
+ return __generator(this, function (_d) {
1019
+ switch (_d.label) {
1082
1020
  case 0:
1083
1021
  _a = [__assign({}, output)];
1084
- _j = {};
1022
+ _c = {};
1085
1023
  return [4, parseBody(output.body, context)];
1086
1024
  case 1:
1087
- parsedOutput = __assign.apply(void 0, _a.concat([(_j.body = _k.sent(), _j)]));
1025
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1088
1026
  errorCode = "UnknownError";
1089
1027
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1090
1028
  _b = errorCode;
@@ -1103,52 +1041,26 @@ var deserializeAws_queryCreateStackInstancesCommandError = function (output, con
1103
1041
  case "com.amazonaws.cloudformation#StaleRequestException": return [3, 12];
1104
1042
  }
1105
1043
  return [3, 14];
1106
- case 2:
1107
- _c = [{}];
1108
- return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
1109
- case 3:
1110
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1111
- return [3, 15];
1112
- case 4:
1113
- _d = [{}];
1114
- return [4, deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)];
1115
- case 5:
1116
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1117
- return [3, 15];
1118
- case 6:
1119
- _e = [{}];
1120
- return [4, deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)];
1121
- case 7:
1122
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1123
- return [3, 15];
1124
- case 8:
1125
- _f = [{}];
1126
- return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
1127
- case 9:
1128
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1129
- return [3, 15];
1130
- case 10:
1131
- _g = [{}];
1132
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
1133
- case 11:
1134
- response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1135
- return [3, 15];
1136
- case 12:
1137
- _h = [{}];
1138
- return [4, deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)];
1139
- case 13:
1140
- response = __assign.apply(void 0, [__assign.apply(void 0, _h.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1141
- return [3, 15];
1044
+ case 2: return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
1045
+ case 3: throw _d.sent();
1046
+ case 4: return [4, deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)];
1047
+ case 5: throw _d.sent();
1048
+ case 6: return [4, deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)];
1049
+ case 7: throw _d.sent();
1050
+ case 8: return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
1051
+ case 9: throw _d.sent();
1052
+ case 10: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
1053
+ case 11: throw _d.sent();
1054
+ case 12: return [4, deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)];
1055
+ case 13: throw _d.sent();
1142
1056
  case 14:
1143
1057
  parsedBody = parsedOutput.body;
1144
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1145
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1146
- _k.label = 15;
1147
- case 15:
1148
- message = response.message || response.Message || errorCode;
1149
- response.message = message;
1150
- delete response.Message;
1151
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1058
+ response = new __BaseException({
1059
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1060
+ $fault: "client",
1061
+ $metadata: deserializeMetadata(output),
1062
+ });
1063
+ throw __decorateServiceException(response, parsedBody.Error);
1152
1064
  }
1153
1065
  });
1154
1066
  }); };
@@ -1171,16 +1083,16 @@ export var deserializeAws_queryCreateStackSetCommand = function (output, context
1171
1083
  });
1172
1084
  }); };
1173
1085
  var deserializeAws_queryCreateStackSetCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1174
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
1175
- var _f;
1176
- return __generator(this, function (_g) {
1177
- switch (_g.label) {
1086
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1087
+ var _c;
1088
+ return __generator(this, function (_d) {
1089
+ switch (_d.label) {
1178
1090
  case 0:
1179
1091
  _a = [__assign({}, output)];
1180
- _f = {};
1092
+ _c = {};
1181
1093
  return [4, parseBody(output.body, context)];
1182
1094
  case 1:
1183
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
1095
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1184
1096
  errorCode = "UnknownError";
1185
1097
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1186
1098
  _b = errorCode;
@@ -1193,34 +1105,20 @@ var deserializeAws_queryCreateStackSetCommandError = function (output, context)
1193
1105
  case "com.amazonaws.cloudformation#NameAlreadyExistsException": return [3, 6];
1194
1106
  }
1195
1107
  return [3, 8];
1196
- case 2:
1197
- _c = [{}];
1198
- return [4, deserializeAws_queryCreatedButModifiedExceptionResponse(parsedOutput, context)];
1199
- case 3:
1200
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1201
- return [3, 9];
1202
- case 4:
1203
- _d = [{}];
1204
- return [4, deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)];
1205
- case 5:
1206
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1207
- return [3, 9];
1208
- case 6:
1209
- _e = [{}];
1210
- return [4, deserializeAws_queryNameAlreadyExistsExceptionResponse(parsedOutput, context)];
1211
- case 7:
1212
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1213
- return [3, 9];
1108
+ case 2: return [4, deserializeAws_queryCreatedButModifiedExceptionResponse(parsedOutput, context)];
1109
+ case 3: throw _d.sent();
1110
+ case 4: return [4, deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)];
1111
+ case 5: throw _d.sent();
1112
+ case 6: return [4, deserializeAws_queryNameAlreadyExistsExceptionResponse(parsedOutput, context)];
1113
+ case 7: throw _d.sent();
1214
1114
  case 8:
1215
1115
  parsedBody = parsedOutput.body;
1216
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1217
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1218
- _g.label = 9;
1219
- case 9:
1220
- message = response.message || response.Message || errorCode;
1221
- response.message = message;
1222
- delete response.Message;
1223
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1116
+ response = new __BaseException({
1117
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1118
+ $fault: "client",
1119
+ $metadata: deserializeMetadata(output),
1120
+ });
1121
+ throw __decorateServiceException(response, parsedBody.Error);
1224
1122
  }
1225
1123
  });
1226
1124
  }); };
@@ -1243,16 +1141,16 @@ export var deserializeAws_queryDeactivateTypeCommand = function (output, context
1243
1141
  });
1244
1142
  }); };
1245
1143
  var deserializeAws_queryDeactivateTypeCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1246
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
1247
- var _e;
1248
- return __generator(this, function (_f) {
1249
- switch (_f.label) {
1144
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1145
+ var _c;
1146
+ return __generator(this, function (_d) {
1147
+ switch (_d.label) {
1250
1148
  case 0:
1251
1149
  _a = [__assign({}, output)];
1252
- _e = {};
1150
+ _c = {};
1253
1151
  return [4, parseBody(output.body, context)];
1254
1152
  case 1:
1255
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
1153
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1256
1154
  errorCode = "UnknownError";
1257
1155
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1258
1156
  _b = errorCode;
@@ -1263,28 +1161,18 @@ var deserializeAws_queryDeactivateTypeCommandError = function (output, context)
1263
1161
  case "com.amazonaws.cloudformation#TypeNotFoundException": return [3, 4];
1264
1162
  }
1265
1163
  return [3, 6];
1266
- case 2:
1267
- _c = [{}];
1268
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
1269
- case 3:
1270
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1271
- return [3, 7];
1272
- case 4:
1273
- _d = [{}];
1274
- return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
1275
- case 5:
1276
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1277
- return [3, 7];
1164
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
1165
+ case 3: throw _d.sent();
1166
+ case 4: return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
1167
+ case 5: throw _d.sent();
1278
1168
  case 6:
1279
1169
  parsedBody = parsedOutput.body;
1280
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1281
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1282
- _f.label = 7;
1283
- case 7:
1284
- message = response.message || response.Message || errorCode;
1285
- response.message = message;
1286
- delete response.Message;
1287
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1170
+ response = new __BaseException({
1171
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1172
+ $fault: "client",
1173
+ $metadata: deserializeMetadata(output),
1174
+ });
1175
+ throw __decorateServiceException(response, parsedBody.Error);
1288
1176
  }
1289
1177
  });
1290
1178
  }); };
@@ -1307,16 +1195,16 @@ export var deserializeAws_queryDeleteChangeSetCommand = function (output, contex
1307
1195
  });
1308
1196
  }); };
1309
1197
  var deserializeAws_queryDeleteChangeSetCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1310
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
1311
- var _d;
1312
- return __generator(this, function (_e) {
1313
- switch (_e.label) {
1198
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1199
+ var _c;
1200
+ return __generator(this, function (_d) {
1201
+ switch (_d.label) {
1314
1202
  case 0:
1315
1203
  _a = [__assign({}, output)];
1316
- _d = {};
1204
+ _c = {};
1317
1205
  return [4, parseBody(output.body, context)];
1318
1206
  case 1:
1319
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
1207
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1320
1208
  errorCode = "UnknownError";
1321
1209
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1322
1210
  _b = errorCode;
@@ -1325,22 +1213,16 @@ var deserializeAws_queryDeleteChangeSetCommandError = function (output, context)
1325
1213
  case "com.amazonaws.cloudformation#InvalidChangeSetStatusException": return [3, 2];
1326
1214
  }
1327
1215
  return [3, 4];
1328
- case 2:
1329
- _c = [{}];
1330
- return [4, deserializeAws_queryInvalidChangeSetStatusExceptionResponse(parsedOutput, context)];
1331
- case 3:
1332
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1333
- return [3, 5];
1216
+ case 2: return [4, deserializeAws_queryInvalidChangeSetStatusExceptionResponse(parsedOutput, context)];
1217
+ case 3: throw _d.sent();
1334
1218
  case 4:
1335
1219
  parsedBody = parsedOutput.body;
1336
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1337
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1338
- _e.label = 5;
1339
- case 5:
1340
- message = response.message || response.Message || errorCode;
1341
- response.message = message;
1342
- delete response.Message;
1343
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1220
+ response = new __BaseException({
1221
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1222
+ $fault: "client",
1223
+ $metadata: deserializeMetadata(output),
1224
+ });
1225
+ throw __decorateServiceException(response, parsedBody.Error);
1344
1226
  }
1345
1227
  });
1346
1228
  }); };
@@ -1363,16 +1245,16 @@ export var deserializeAws_queryDeleteStackCommand = function (output, context) {
1363
1245
  });
1364
1246
  }); };
1365
1247
  var deserializeAws_queryDeleteStackCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1366
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
1367
- var _d;
1368
- return __generator(this, function (_e) {
1369
- switch (_e.label) {
1248
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1249
+ var _c;
1250
+ return __generator(this, function (_d) {
1251
+ switch (_d.label) {
1370
1252
  case 0:
1371
1253
  _a = [__assign({}, output)];
1372
- _d = {};
1254
+ _c = {};
1373
1255
  return [4, parseBody(output.body, context)];
1374
1256
  case 1:
1375
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
1257
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1376
1258
  errorCode = "UnknownError";
1377
1259
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1378
1260
  _b = errorCode;
@@ -1381,22 +1263,16 @@ var deserializeAws_queryDeleteStackCommandError = function (output, context) { r
1381
1263
  case "com.amazonaws.cloudformation#TokenAlreadyExistsException": return [3, 2];
1382
1264
  }
1383
1265
  return [3, 4];
1384
- case 2:
1385
- _c = [{}];
1386
- return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
1387
- case 3:
1388
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1389
- return [3, 5];
1266
+ case 2: return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
1267
+ case 3: throw _d.sent();
1390
1268
  case 4:
1391
1269
  parsedBody = parsedOutput.body;
1392
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1393
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1394
- _e.label = 5;
1395
- case 5:
1396
- message = response.message || response.Message || errorCode;
1397
- response.message = message;
1398
- delete response.Message;
1399
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1270
+ response = new __BaseException({
1271
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1272
+ $fault: "client",
1273
+ $metadata: deserializeMetadata(output),
1274
+ });
1275
+ throw __decorateServiceException(response, parsedBody.Error);
1400
1276
  }
1401
1277
  });
1402
1278
  }); };
@@ -1419,16 +1295,16 @@ export var deserializeAws_queryDeleteStackInstancesCommand = function (output, c
1419
1295
  });
1420
1296
  }); };
1421
1297
  var deserializeAws_queryDeleteStackInstancesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1422
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, parsedBody, message;
1423
- var _h;
1424
- return __generator(this, function (_j) {
1425
- switch (_j.label) {
1298
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1299
+ var _c;
1300
+ return __generator(this, function (_d) {
1301
+ switch (_d.label) {
1426
1302
  case 0:
1427
1303
  _a = [__assign({}, output)];
1428
- _h = {};
1304
+ _c = {};
1429
1305
  return [4, parseBody(output.body, context)];
1430
1306
  case 1:
1431
- parsedOutput = __assign.apply(void 0, _a.concat([(_h.body = _j.sent(), _h)]));
1307
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1432
1308
  errorCode = "UnknownError";
1433
1309
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1434
1310
  _b = errorCode;
@@ -1445,46 +1321,24 @@ var deserializeAws_queryDeleteStackInstancesCommandError = function (output, con
1445
1321
  case "com.amazonaws.cloudformation#StaleRequestException": return [3, 10];
1446
1322
  }
1447
1323
  return [3, 12];
1448
- case 2:
1449
- _c = [{}];
1450
- return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
1451
- case 3:
1452
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1453
- return [3, 13];
1454
- case 4:
1455
- _d = [{}];
1456
- return [4, deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)];
1457
- case 5:
1458
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1459
- return [3, 13];
1460
- case 6:
1461
- _e = [{}];
1462
- return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
1463
- case 7:
1464
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1465
- return [3, 13];
1466
- case 8:
1467
- _f = [{}];
1468
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
1469
- case 9:
1470
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1471
- return [3, 13];
1472
- case 10:
1473
- _g = [{}];
1474
- return [4, deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)];
1475
- case 11:
1476
- response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1477
- return [3, 13];
1324
+ case 2: return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
1325
+ case 3: throw _d.sent();
1326
+ case 4: return [4, deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)];
1327
+ case 5: throw _d.sent();
1328
+ case 6: return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
1329
+ case 7: throw _d.sent();
1330
+ case 8: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
1331
+ case 9: throw _d.sent();
1332
+ case 10: return [4, deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)];
1333
+ case 11: throw _d.sent();
1478
1334
  case 12:
1479
1335
  parsedBody = parsedOutput.body;
1480
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1481
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1482
- _j.label = 13;
1483
- case 13:
1484
- message = response.message || response.Message || errorCode;
1485
- response.message = message;
1486
- delete response.Message;
1487
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1336
+ response = new __BaseException({
1337
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1338
+ $fault: "client",
1339
+ $metadata: deserializeMetadata(output),
1340
+ });
1341
+ throw __decorateServiceException(response, parsedBody.Error);
1488
1342
  }
1489
1343
  });
1490
1344
  }); };
@@ -1507,16 +1361,16 @@ export var deserializeAws_queryDeleteStackSetCommand = function (output, context
1507
1361
  });
1508
1362
  }); };
1509
1363
  var deserializeAws_queryDeleteStackSetCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1510
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
1511
- var _e;
1512
- return __generator(this, function (_f) {
1513
- switch (_f.label) {
1364
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1365
+ var _c;
1366
+ return __generator(this, function (_d) {
1367
+ switch (_d.label) {
1514
1368
  case 0:
1515
1369
  _a = [__assign({}, output)];
1516
- _e = {};
1370
+ _c = {};
1517
1371
  return [4, parseBody(output.body, context)];
1518
1372
  case 1:
1519
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
1373
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1520
1374
  errorCode = "UnknownError";
1521
1375
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1522
1376
  _b = errorCode;
@@ -1527,28 +1381,18 @@ var deserializeAws_queryDeleteStackSetCommandError = function (output, context)
1527
1381
  case "com.amazonaws.cloudformation#StackSetNotEmptyException": return [3, 4];
1528
1382
  }
1529
1383
  return [3, 6];
1530
- case 2:
1531
- _c = [{}];
1532
- return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
1533
- case 3:
1534
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1535
- return [3, 7];
1536
- case 4:
1537
- _d = [{}];
1538
- return [4, deserializeAws_queryStackSetNotEmptyExceptionResponse(parsedOutput, context)];
1539
- case 5:
1540
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1541
- return [3, 7];
1384
+ case 2: return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
1385
+ case 3: throw _d.sent();
1386
+ case 4: return [4, deserializeAws_queryStackSetNotEmptyExceptionResponse(parsedOutput, context)];
1387
+ case 5: throw _d.sent();
1542
1388
  case 6:
1543
1389
  parsedBody = parsedOutput.body;
1544
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1545
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1546
- _f.label = 7;
1547
- case 7:
1548
- message = response.message || response.Message || errorCode;
1549
- response.message = message;
1550
- delete response.Message;
1551
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1390
+ response = new __BaseException({
1391
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1392
+ $fault: "client",
1393
+ $metadata: deserializeMetadata(output),
1394
+ });
1395
+ throw __decorateServiceException(response, parsedBody.Error);
1552
1396
  }
1553
1397
  });
1554
1398
  }); };
@@ -1571,16 +1415,16 @@ export var deserializeAws_queryDeregisterTypeCommand = function (output, context
1571
1415
  });
1572
1416
  }); };
1573
1417
  var deserializeAws_queryDeregisterTypeCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1574
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
1575
- var _e;
1576
- return __generator(this, function (_f) {
1577
- switch (_f.label) {
1418
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1419
+ var _c;
1420
+ return __generator(this, function (_d) {
1421
+ switch (_d.label) {
1578
1422
  case 0:
1579
1423
  _a = [__assign({}, output)];
1580
- _e = {};
1424
+ _c = {};
1581
1425
  return [4, parseBody(output.body, context)];
1582
1426
  case 1:
1583
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
1427
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1584
1428
  errorCode = "UnknownError";
1585
1429
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1586
1430
  _b = errorCode;
@@ -1591,28 +1435,18 @@ var deserializeAws_queryDeregisterTypeCommandError = function (output, context)
1591
1435
  case "com.amazonaws.cloudformation#TypeNotFoundException": return [3, 4];
1592
1436
  }
1593
1437
  return [3, 6];
1594
- case 2:
1595
- _c = [{}];
1596
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
1597
- case 3:
1598
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1599
- return [3, 7];
1600
- case 4:
1601
- _d = [{}];
1602
- return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
1603
- case 5:
1604
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1605
- return [3, 7];
1438
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
1439
+ case 3: throw _d.sent();
1440
+ case 4: return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
1441
+ case 5: throw _d.sent();
1606
1442
  case 6:
1607
1443
  parsedBody = parsedOutput.body;
1608
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1609
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1610
- _f.label = 7;
1611
- case 7:
1612
- message = response.message || response.Message || errorCode;
1613
- response.message = message;
1614
- delete response.Message;
1615
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1444
+ response = new __BaseException({
1445
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1446
+ $fault: "client",
1447
+ $metadata: deserializeMetadata(output),
1448
+ });
1449
+ throw __decorateServiceException(response, parsedBody.Error);
1616
1450
  }
1617
1451
  });
1618
1452
  }); };
@@ -1635,7 +1469,7 @@ export var deserializeAws_queryDescribeAccountLimitsCommand = function (output,
1635
1469
  });
1636
1470
  }); };
1637
1471
  var deserializeAws_queryDescribeAccountLimitsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1638
- var parsedOutput, _a, response, errorCode, parsedBody, message;
1472
+ var parsedOutput, _a, response, errorCode, parsedBody;
1639
1473
  var _b;
1640
1474
  return __generator(this, function (_c) {
1641
1475
  switch (_c.label) {
@@ -1650,13 +1484,14 @@ var deserializeAws_queryDescribeAccountLimitsCommandError = function (output, co
1650
1484
  switch (errorCode) {
1651
1485
  default:
1652
1486
  parsedBody = parsedOutput.body;
1653
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1654
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1487
+ response = new __BaseException({
1488
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1489
+ $fault: "client",
1490
+ $metadata: deserializeMetadata(output),
1491
+ });
1492
+ throw __decorateServiceException(response, parsedBody.Error);
1655
1493
  }
1656
- message = response.message || response.Message || errorCode;
1657
- response.message = message;
1658
- delete response.Message;
1659
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1494
+ return [2];
1660
1495
  }
1661
1496
  });
1662
1497
  }); };
@@ -1679,16 +1514,16 @@ export var deserializeAws_queryDescribeChangeSetCommand = function (output, cont
1679
1514
  });
1680
1515
  }); };
1681
1516
  var deserializeAws_queryDescribeChangeSetCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1682
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
1683
- var _d;
1684
- return __generator(this, function (_e) {
1685
- switch (_e.label) {
1517
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1518
+ var _c;
1519
+ return __generator(this, function (_d) {
1520
+ switch (_d.label) {
1686
1521
  case 0:
1687
1522
  _a = [__assign({}, output)];
1688
- _d = {};
1523
+ _c = {};
1689
1524
  return [4, parseBody(output.body, context)];
1690
1525
  case 1:
1691
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
1526
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1692
1527
  errorCode = "UnknownError";
1693
1528
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1694
1529
  _b = errorCode;
@@ -1697,22 +1532,16 @@ var deserializeAws_queryDescribeChangeSetCommandError = function (output, contex
1697
1532
  case "com.amazonaws.cloudformation#ChangeSetNotFoundException": return [3, 2];
1698
1533
  }
1699
1534
  return [3, 4];
1700
- case 2:
1701
- _c = [{}];
1702
- return [4, deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)];
1703
- case 3:
1704
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1705
- return [3, 5];
1535
+ case 2: return [4, deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)];
1536
+ case 3: throw _d.sent();
1706
1537
  case 4:
1707
1538
  parsedBody = parsedOutput.body;
1708
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1709
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1710
- _e.label = 5;
1711
- case 5:
1712
- message = response.message || response.Message || errorCode;
1713
- response.message = message;
1714
- delete response.Message;
1715
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1539
+ response = new __BaseException({
1540
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1541
+ $fault: "client",
1542
+ $metadata: deserializeMetadata(output),
1543
+ });
1544
+ throw __decorateServiceException(response, parsedBody.Error);
1716
1545
  }
1717
1546
  });
1718
1547
  }); };
@@ -1735,16 +1564,16 @@ export var deserializeAws_queryDescribeChangeSetHooksCommand = function (output,
1735
1564
  });
1736
1565
  }); };
1737
1566
  var deserializeAws_queryDescribeChangeSetHooksCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1738
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
1739
- var _d;
1740
- return __generator(this, function (_e) {
1741
- switch (_e.label) {
1567
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1568
+ var _c;
1569
+ return __generator(this, function (_d) {
1570
+ switch (_d.label) {
1742
1571
  case 0:
1743
1572
  _a = [__assign({}, output)];
1744
- _d = {};
1573
+ _c = {};
1745
1574
  return [4, parseBody(output.body, context)];
1746
1575
  case 1:
1747
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
1576
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1748
1577
  errorCode = "UnknownError";
1749
1578
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1750
1579
  _b = errorCode;
@@ -1753,22 +1582,16 @@ var deserializeAws_queryDescribeChangeSetHooksCommandError = function (output, c
1753
1582
  case "com.amazonaws.cloudformation#ChangeSetNotFoundException": return [3, 2];
1754
1583
  }
1755
1584
  return [3, 4];
1756
- case 2:
1757
- _c = [{}];
1758
- return [4, deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)];
1759
- case 3:
1760
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1761
- return [3, 5];
1585
+ case 2: return [4, deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)];
1586
+ case 3: throw _d.sent();
1762
1587
  case 4:
1763
1588
  parsedBody = parsedOutput.body;
1764
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1765
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1766
- _e.label = 5;
1767
- case 5:
1768
- message = response.message || response.Message || errorCode;
1769
- response.message = message;
1770
- delete response.Message;
1771
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1589
+ response = new __BaseException({
1590
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1591
+ $fault: "client",
1592
+ $metadata: deserializeMetadata(output),
1593
+ });
1594
+ throw __decorateServiceException(response, parsedBody.Error);
1772
1595
  }
1773
1596
  });
1774
1597
  }); };
@@ -1791,16 +1614,16 @@ export var deserializeAws_queryDescribePublisherCommand = function (output, cont
1791
1614
  });
1792
1615
  }); };
1793
1616
  var deserializeAws_queryDescribePublisherCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1794
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
1795
- var _d;
1796
- return __generator(this, function (_e) {
1797
- switch (_e.label) {
1617
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1618
+ var _c;
1619
+ return __generator(this, function (_d) {
1620
+ switch (_d.label) {
1798
1621
  case 0:
1799
1622
  _a = [__assign({}, output)];
1800
- _d = {};
1623
+ _c = {};
1801
1624
  return [4, parseBody(output.body, context)];
1802
1625
  case 1:
1803
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
1626
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1804
1627
  errorCode = "UnknownError";
1805
1628
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1806
1629
  _b = errorCode;
@@ -1809,22 +1632,16 @@ var deserializeAws_queryDescribePublisherCommandError = function (output, contex
1809
1632
  case "com.amazonaws.cloudformation#CFNRegistryException": return [3, 2];
1810
1633
  }
1811
1634
  return [3, 4];
1812
- case 2:
1813
- _c = [{}];
1814
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
1815
- case 3:
1816
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1817
- return [3, 5];
1635
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
1636
+ case 3: throw _d.sent();
1818
1637
  case 4:
1819
1638
  parsedBody = parsedOutput.body;
1820
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1821
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1822
- _e.label = 5;
1823
- case 5:
1824
- message = response.message || response.Message || errorCode;
1825
- response.message = message;
1826
- delete response.Message;
1827
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1639
+ response = new __BaseException({
1640
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1641
+ $fault: "client",
1642
+ $metadata: deserializeMetadata(output),
1643
+ });
1644
+ throw __decorateServiceException(response, parsedBody.Error);
1828
1645
  }
1829
1646
  });
1830
1647
  }); };
@@ -1847,7 +1664,7 @@ export var deserializeAws_queryDescribeStackDriftDetectionStatusCommand = functi
1847
1664
  });
1848
1665
  }); };
1849
1666
  var deserializeAws_queryDescribeStackDriftDetectionStatusCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1850
- var parsedOutput, _a, response, errorCode, parsedBody, message;
1667
+ var parsedOutput, _a, response, errorCode, parsedBody;
1851
1668
  var _b;
1852
1669
  return __generator(this, function (_c) {
1853
1670
  switch (_c.label) {
@@ -1862,13 +1679,14 @@ var deserializeAws_queryDescribeStackDriftDetectionStatusCommandError = function
1862
1679
  switch (errorCode) {
1863
1680
  default:
1864
1681
  parsedBody = parsedOutput.body;
1865
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1866
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1682
+ response = new __BaseException({
1683
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1684
+ $fault: "client",
1685
+ $metadata: deserializeMetadata(output),
1686
+ });
1687
+ throw __decorateServiceException(response, parsedBody.Error);
1867
1688
  }
1868
- message = response.message || response.Message || errorCode;
1869
- response.message = message;
1870
- delete response.Message;
1871
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1689
+ return [2];
1872
1690
  }
1873
1691
  });
1874
1692
  }); };
@@ -1891,7 +1709,7 @@ export var deserializeAws_queryDescribeStackEventsCommand = function (output, co
1891
1709
  });
1892
1710
  }); };
1893
1711
  var deserializeAws_queryDescribeStackEventsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1894
- var parsedOutput, _a, response, errorCode, parsedBody, message;
1712
+ var parsedOutput, _a, response, errorCode, parsedBody;
1895
1713
  var _b;
1896
1714
  return __generator(this, function (_c) {
1897
1715
  switch (_c.label) {
@@ -1906,13 +1724,14 @@ var deserializeAws_queryDescribeStackEventsCommandError = function (output, cont
1906
1724
  switch (errorCode) {
1907
1725
  default:
1908
1726
  parsedBody = parsedOutput.body;
1909
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1910
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1727
+ response = new __BaseException({
1728
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1729
+ $fault: "client",
1730
+ $metadata: deserializeMetadata(output),
1731
+ });
1732
+ throw __decorateServiceException(response, parsedBody.Error);
1911
1733
  }
1912
- message = response.message || response.Message || errorCode;
1913
- response.message = message;
1914
- delete response.Message;
1915
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1734
+ return [2];
1916
1735
  }
1917
1736
  });
1918
1737
  }); };
@@ -1935,16 +1754,16 @@ export var deserializeAws_queryDescribeStackInstanceCommand = function (output,
1935
1754
  });
1936
1755
  }); };
1937
1756
  var deserializeAws_queryDescribeStackInstanceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
1938
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
1939
- var _e;
1940
- return __generator(this, function (_f) {
1941
- switch (_f.label) {
1757
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1758
+ var _c;
1759
+ return __generator(this, function (_d) {
1760
+ switch (_d.label) {
1942
1761
  case 0:
1943
1762
  _a = [__assign({}, output)];
1944
- _e = {};
1763
+ _c = {};
1945
1764
  return [4, parseBody(output.body, context)];
1946
1765
  case 1:
1947
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
1766
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
1948
1767
  errorCode = "UnknownError";
1949
1768
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
1950
1769
  _b = errorCode;
@@ -1955,28 +1774,18 @@ var deserializeAws_queryDescribeStackInstanceCommandError = function (output, co
1955
1774
  case "com.amazonaws.cloudformation#StackSetNotFoundException": return [3, 4];
1956
1775
  }
1957
1776
  return [3, 6];
1958
- case 2:
1959
- _c = [{}];
1960
- return [4, deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context)];
1961
- case 3:
1962
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1963
- return [3, 7];
1964
- case 4:
1965
- _d = [{}];
1966
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
1967
- case 5:
1968
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
1969
- return [3, 7];
1777
+ case 2: return [4, deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context)];
1778
+ case 3: throw _d.sent();
1779
+ case 4: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
1780
+ case 5: throw _d.sent();
1970
1781
  case 6:
1971
1782
  parsedBody = parsedOutput.body;
1972
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1973
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1974
- _f.label = 7;
1975
- case 7:
1976
- message = response.message || response.Message || errorCode;
1977
- response.message = message;
1978
- delete response.Message;
1979
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1783
+ response = new __BaseException({
1784
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1785
+ $fault: "client",
1786
+ $metadata: deserializeMetadata(output),
1787
+ });
1788
+ throw __decorateServiceException(response, parsedBody.Error);
1980
1789
  }
1981
1790
  });
1982
1791
  }); };
@@ -1999,7 +1808,7 @@ export var deserializeAws_queryDescribeStackResourceCommand = function (output,
1999
1808
  });
2000
1809
  }); };
2001
1810
  var deserializeAws_queryDescribeStackResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2002
- var parsedOutput, _a, response, errorCode, parsedBody, message;
1811
+ var parsedOutput, _a, response, errorCode, parsedBody;
2003
1812
  var _b;
2004
1813
  return __generator(this, function (_c) {
2005
1814
  switch (_c.label) {
@@ -2014,13 +1823,14 @@ var deserializeAws_queryDescribeStackResourceCommandError = function (output, co
2014
1823
  switch (errorCode) {
2015
1824
  default:
2016
1825
  parsedBody = parsedOutput.body;
2017
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2018
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1826
+ response = new __BaseException({
1827
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1828
+ $fault: "client",
1829
+ $metadata: deserializeMetadata(output),
1830
+ });
1831
+ throw __decorateServiceException(response, parsedBody.Error);
2019
1832
  }
2020
- message = response.message || response.Message || errorCode;
2021
- response.message = message;
2022
- delete response.Message;
2023
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1833
+ return [2];
2024
1834
  }
2025
1835
  });
2026
1836
  }); };
@@ -2043,7 +1853,7 @@ export var deserializeAws_queryDescribeStackResourceDriftsCommand = function (ou
2043
1853
  });
2044
1854
  }); };
2045
1855
  var deserializeAws_queryDescribeStackResourceDriftsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2046
- var parsedOutput, _a, response, errorCode, parsedBody, message;
1856
+ var parsedOutput, _a, response, errorCode, parsedBody;
2047
1857
  var _b;
2048
1858
  return __generator(this, function (_c) {
2049
1859
  switch (_c.label) {
@@ -2058,13 +1868,14 @@ var deserializeAws_queryDescribeStackResourceDriftsCommandError = function (outp
2058
1868
  switch (errorCode) {
2059
1869
  default:
2060
1870
  parsedBody = parsedOutput.body;
2061
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2062
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1871
+ response = new __BaseException({
1872
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1873
+ $fault: "client",
1874
+ $metadata: deserializeMetadata(output),
1875
+ });
1876
+ throw __decorateServiceException(response, parsedBody.Error);
2063
1877
  }
2064
- message = response.message || response.Message || errorCode;
2065
- response.message = message;
2066
- delete response.Message;
2067
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1878
+ return [2];
2068
1879
  }
2069
1880
  });
2070
1881
  }); };
@@ -2087,7 +1898,7 @@ export var deserializeAws_queryDescribeStackResourcesCommand = function (output,
2087
1898
  });
2088
1899
  }); };
2089
1900
  var deserializeAws_queryDescribeStackResourcesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2090
- var parsedOutput, _a, response, errorCode, parsedBody, message;
1901
+ var parsedOutput, _a, response, errorCode, parsedBody;
2091
1902
  var _b;
2092
1903
  return __generator(this, function (_c) {
2093
1904
  switch (_c.label) {
@@ -2102,13 +1913,14 @@ var deserializeAws_queryDescribeStackResourcesCommandError = function (output, c
2102
1913
  switch (errorCode) {
2103
1914
  default:
2104
1915
  parsedBody = parsedOutput.body;
2105
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2106
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1916
+ response = new __BaseException({
1917
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1918
+ $fault: "client",
1919
+ $metadata: deserializeMetadata(output),
1920
+ });
1921
+ throw __decorateServiceException(response, parsedBody.Error);
2107
1922
  }
2108
- message = response.message || response.Message || errorCode;
2109
- response.message = message;
2110
- delete response.Message;
2111
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1923
+ return [2];
2112
1924
  }
2113
1925
  });
2114
1926
  }); };
@@ -2131,7 +1943,7 @@ export var deserializeAws_queryDescribeStacksCommand = function (output, context
2131
1943
  });
2132
1944
  }); };
2133
1945
  var deserializeAws_queryDescribeStacksCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2134
- var parsedOutput, _a, response, errorCode, parsedBody, message;
1946
+ var parsedOutput, _a, response, errorCode, parsedBody;
2135
1947
  var _b;
2136
1948
  return __generator(this, function (_c) {
2137
1949
  switch (_c.label) {
@@ -2146,13 +1958,14 @@ var deserializeAws_queryDescribeStacksCommandError = function (output, context)
2146
1958
  switch (errorCode) {
2147
1959
  default:
2148
1960
  parsedBody = parsedOutput.body;
2149
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2150
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
1961
+ response = new __BaseException({
1962
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1963
+ $fault: "client",
1964
+ $metadata: deserializeMetadata(output),
1965
+ });
1966
+ throw __decorateServiceException(response, parsedBody.Error);
2151
1967
  }
2152
- message = response.message || response.Message || errorCode;
2153
- response.message = message;
2154
- delete response.Message;
2155
- return [2, Promise.reject(Object.assign(new Error(message), response))];
1968
+ return [2];
2156
1969
  }
2157
1970
  });
2158
1971
  }); };
@@ -2175,16 +1988,16 @@ export var deserializeAws_queryDescribeStackSetCommand = function (output, conte
2175
1988
  });
2176
1989
  }); };
2177
1990
  var deserializeAws_queryDescribeStackSetCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2178
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
2179
- var _d;
2180
- return __generator(this, function (_e) {
2181
- switch (_e.label) {
1991
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
1992
+ var _c;
1993
+ return __generator(this, function (_d) {
1994
+ switch (_d.label) {
2182
1995
  case 0:
2183
1996
  _a = [__assign({}, output)];
2184
- _d = {};
1997
+ _c = {};
2185
1998
  return [4, parseBody(output.body, context)];
2186
1999
  case 1:
2187
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
2000
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2188
2001
  errorCode = "UnknownError";
2189
2002
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
2190
2003
  _b = errorCode;
@@ -2193,22 +2006,16 @@ var deserializeAws_queryDescribeStackSetCommandError = function (output, context
2193
2006
  case "com.amazonaws.cloudformation#StackSetNotFoundException": return [3, 2];
2194
2007
  }
2195
2008
  return [3, 4];
2196
- case 2:
2197
- _c = [{}];
2198
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2199
- case 3:
2200
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2201
- return [3, 5];
2009
+ case 2: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2010
+ case 3: throw _d.sent();
2202
2011
  case 4:
2203
2012
  parsedBody = parsedOutput.body;
2204
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2205
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2206
- _e.label = 5;
2207
- case 5:
2208
- message = response.message || response.Message || errorCode;
2209
- response.message = message;
2210
- delete response.Message;
2211
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2013
+ response = new __BaseException({
2014
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2015
+ $fault: "client",
2016
+ $metadata: deserializeMetadata(output),
2017
+ });
2018
+ throw __decorateServiceException(response, parsedBody.Error);
2212
2019
  }
2213
2020
  });
2214
2021
  }); };
@@ -2231,16 +2038,16 @@ export var deserializeAws_queryDescribeStackSetOperationCommand = function (outp
2231
2038
  });
2232
2039
  }); };
2233
2040
  var deserializeAws_queryDescribeStackSetOperationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2234
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
2235
- var _e;
2236
- return __generator(this, function (_f) {
2237
- switch (_f.label) {
2041
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2042
+ var _c;
2043
+ return __generator(this, function (_d) {
2044
+ switch (_d.label) {
2238
2045
  case 0:
2239
2046
  _a = [__assign({}, output)];
2240
- _e = {};
2047
+ _c = {};
2241
2048
  return [4, parseBody(output.body, context)];
2242
2049
  case 1:
2243
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
2050
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2244
2051
  errorCode = "UnknownError";
2245
2052
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
2246
2053
  _b = errorCode;
@@ -2251,28 +2058,18 @@ var deserializeAws_queryDescribeStackSetOperationCommandError = function (output
2251
2058
  case "com.amazonaws.cloudformation#StackSetNotFoundException": return [3, 4];
2252
2059
  }
2253
2060
  return [3, 6];
2254
- case 2:
2255
- _c = [{}];
2256
- return [4, deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context)];
2257
- case 3:
2258
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2259
- return [3, 7];
2260
- case 4:
2261
- _d = [{}];
2262
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2263
- case 5:
2264
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2265
- return [3, 7];
2061
+ case 2: return [4, deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context)];
2062
+ case 3: throw _d.sent();
2063
+ case 4: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2064
+ case 5: throw _d.sent();
2266
2065
  case 6:
2267
2066
  parsedBody = parsedOutput.body;
2268
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2269
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2270
- _f.label = 7;
2271
- case 7:
2272
- message = response.message || response.Message || errorCode;
2273
- response.message = message;
2274
- delete response.Message;
2275
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2067
+ response = new __BaseException({
2068
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2069
+ $fault: "client",
2070
+ $metadata: deserializeMetadata(output),
2071
+ });
2072
+ throw __decorateServiceException(response, parsedBody.Error);
2276
2073
  }
2277
2074
  });
2278
2075
  }); };
@@ -2295,16 +2092,16 @@ export var deserializeAws_queryDescribeTypeCommand = function (output, context)
2295
2092
  });
2296
2093
  }); };
2297
2094
  var deserializeAws_queryDescribeTypeCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2298
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
2299
- var _e;
2300
- return __generator(this, function (_f) {
2301
- switch (_f.label) {
2095
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2096
+ var _c;
2097
+ return __generator(this, function (_d) {
2098
+ switch (_d.label) {
2302
2099
  case 0:
2303
2100
  _a = [__assign({}, output)];
2304
- _e = {};
2101
+ _c = {};
2305
2102
  return [4, parseBody(output.body, context)];
2306
2103
  case 1:
2307
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
2104
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2308
2105
  errorCode = "UnknownError";
2309
2106
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
2310
2107
  _b = errorCode;
@@ -2315,28 +2112,18 @@ var deserializeAws_queryDescribeTypeCommandError = function (output, context) {
2315
2112
  case "com.amazonaws.cloudformation#TypeNotFoundException": return [3, 4];
2316
2113
  }
2317
2114
  return [3, 6];
2318
- case 2:
2319
- _c = [{}];
2320
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
2321
- case 3:
2322
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2323
- return [3, 7];
2324
- case 4:
2325
- _d = [{}];
2326
- return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
2327
- case 5:
2328
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2329
- return [3, 7];
2115
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
2116
+ case 3: throw _d.sent();
2117
+ case 4: return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
2118
+ case 5: throw _d.sent();
2330
2119
  case 6:
2331
2120
  parsedBody = parsedOutput.body;
2332
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2333
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2334
- _f.label = 7;
2335
- case 7:
2336
- message = response.message || response.Message || errorCode;
2337
- response.message = message;
2338
- delete response.Message;
2339
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2121
+ response = new __BaseException({
2122
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2123
+ $fault: "client",
2124
+ $metadata: deserializeMetadata(output),
2125
+ });
2126
+ throw __decorateServiceException(response, parsedBody.Error);
2340
2127
  }
2341
2128
  });
2342
2129
  }); };
@@ -2359,16 +2146,16 @@ export var deserializeAws_queryDescribeTypeRegistrationCommand = function (outpu
2359
2146
  });
2360
2147
  }); };
2361
2148
  var deserializeAws_queryDescribeTypeRegistrationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2362
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
2363
- var _d;
2364
- return __generator(this, function (_e) {
2365
- switch (_e.label) {
2149
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2150
+ var _c;
2151
+ return __generator(this, function (_d) {
2152
+ switch (_d.label) {
2366
2153
  case 0:
2367
2154
  _a = [__assign({}, output)];
2368
- _d = {};
2155
+ _c = {};
2369
2156
  return [4, parseBody(output.body, context)];
2370
2157
  case 1:
2371
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
2158
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2372
2159
  errorCode = "UnknownError";
2373
2160
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
2374
2161
  _b = errorCode;
@@ -2377,22 +2164,16 @@ var deserializeAws_queryDescribeTypeRegistrationCommandError = function (output,
2377
2164
  case "com.amazonaws.cloudformation#CFNRegistryException": return [3, 2];
2378
2165
  }
2379
2166
  return [3, 4];
2380
- case 2:
2381
- _c = [{}];
2382
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
2383
- case 3:
2384
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2385
- return [3, 5];
2167
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
2168
+ case 3: throw _d.sent();
2386
2169
  case 4:
2387
2170
  parsedBody = parsedOutput.body;
2388
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2389
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2390
- _e.label = 5;
2391
- case 5:
2392
- message = response.message || response.Message || errorCode;
2393
- response.message = message;
2394
- delete response.Message;
2395
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2171
+ response = new __BaseException({
2172
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2173
+ $fault: "client",
2174
+ $metadata: deserializeMetadata(output),
2175
+ });
2176
+ throw __decorateServiceException(response, parsedBody.Error);
2396
2177
  }
2397
2178
  });
2398
2179
  }); };
@@ -2415,7 +2196,7 @@ export var deserializeAws_queryDetectStackDriftCommand = function (output, conte
2415
2196
  });
2416
2197
  }); };
2417
2198
  var deserializeAws_queryDetectStackDriftCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2418
- var parsedOutput, _a, response, errorCode, parsedBody, message;
2199
+ var parsedOutput, _a, response, errorCode, parsedBody;
2419
2200
  var _b;
2420
2201
  return __generator(this, function (_c) {
2421
2202
  switch (_c.label) {
@@ -2430,13 +2211,14 @@ var deserializeAws_queryDetectStackDriftCommandError = function (output, context
2430
2211
  switch (errorCode) {
2431
2212
  default:
2432
2213
  parsedBody = parsedOutput.body;
2433
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2434
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2214
+ response = new __BaseException({
2215
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2216
+ $fault: "client",
2217
+ $metadata: deserializeMetadata(output),
2218
+ });
2219
+ throw __decorateServiceException(response, parsedBody.Error);
2435
2220
  }
2436
- message = response.message || response.Message || errorCode;
2437
- response.message = message;
2438
- delete response.Message;
2439
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2221
+ return [2];
2440
2222
  }
2441
2223
  });
2442
2224
  }); };
@@ -2459,7 +2241,7 @@ export var deserializeAws_queryDetectStackResourceDriftCommand = function (outpu
2459
2241
  });
2460
2242
  }); };
2461
2243
  var deserializeAws_queryDetectStackResourceDriftCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2462
- var parsedOutput, _a, response, errorCode, parsedBody, message;
2244
+ var parsedOutput, _a, response, errorCode, parsedBody;
2463
2245
  var _b;
2464
2246
  return __generator(this, function (_c) {
2465
2247
  switch (_c.label) {
@@ -2474,13 +2256,14 @@ var deserializeAws_queryDetectStackResourceDriftCommandError = function (output,
2474
2256
  switch (errorCode) {
2475
2257
  default:
2476
2258
  parsedBody = parsedOutput.body;
2477
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2478
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2259
+ response = new __BaseException({
2260
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2261
+ $fault: "client",
2262
+ $metadata: deserializeMetadata(output),
2263
+ });
2264
+ throw __decorateServiceException(response, parsedBody.Error);
2479
2265
  }
2480
- message = response.message || response.Message || errorCode;
2481
- response.message = message;
2482
- delete response.Message;
2483
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2266
+ return [2];
2484
2267
  }
2485
2268
  });
2486
2269
  }); };
@@ -2503,16 +2286,16 @@ export var deserializeAws_queryDetectStackSetDriftCommand = function (output, co
2503
2286
  });
2504
2287
  }); };
2505
2288
  var deserializeAws_queryDetectStackSetDriftCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2506
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
2507
- var _f;
2508
- return __generator(this, function (_g) {
2509
- switch (_g.label) {
2289
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2290
+ var _c;
2291
+ return __generator(this, function (_d) {
2292
+ switch (_d.label) {
2510
2293
  case 0:
2511
2294
  _a = [__assign({}, output)];
2512
- _f = {};
2295
+ _c = {};
2513
2296
  return [4, parseBody(output.body, context)];
2514
2297
  case 1:
2515
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
2298
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2516
2299
  errorCode = "UnknownError";
2517
2300
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
2518
2301
  _b = errorCode;
@@ -2525,34 +2308,20 @@ var deserializeAws_queryDetectStackSetDriftCommandError = function (output, cont
2525
2308
  case "com.amazonaws.cloudformation#StackSetNotFoundException": return [3, 6];
2526
2309
  }
2527
2310
  return [3, 8];
2528
- case 2:
2529
- _c = [{}];
2530
- return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
2531
- case 3:
2532
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2533
- return [3, 9];
2534
- case 4:
2535
- _d = [{}];
2536
- return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
2537
- case 5:
2538
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2539
- return [3, 9];
2540
- case 6:
2541
- _e = [{}];
2542
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2543
- case 7:
2544
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2545
- return [3, 9];
2311
+ case 2: return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
2312
+ case 3: throw _d.sent();
2313
+ case 4: return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
2314
+ case 5: throw _d.sent();
2315
+ case 6: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2316
+ case 7: throw _d.sent();
2546
2317
  case 8:
2547
2318
  parsedBody = parsedOutput.body;
2548
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2549
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2550
- _g.label = 9;
2551
- case 9:
2552
- message = response.message || response.Message || errorCode;
2553
- response.message = message;
2554
- delete response.Message;
2555
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2319
+ response = new __BaseException({
2320
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2321
+ $fault: "client",
2322
+ $metadata: deserializeMetadata(output),
2323
+ });
2324
+ throw __decorateServiceException(response, parsedBody.Error);
2556
2325
  }
2557
2326
  });
2558
2327
  }); };
@@ -2575,7 +2344,7 @@ export var deserializeAws_queryEstimateTemplateCostCommand = function (output, c
2575
2344
  });
2576
2345
  }); };
2577
2346
  var deserializeAws_queryEstimateTemplateCostCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2578
- var parsedOutput, _a, response, errorCode, parsedBody, message;
2347
+ var parsedOutput, _a, response, errorCode, parsedBody;
2579
2348
  var _b;
2580
2349
  return __generator(this, function (_c) {
2581
2350
  switch (_c.label) {
@@ -2590,13 +2359,14 @@ var deserializeAws_queryEstimateTemplateCostCommandError = function (output, con
2590
2359
  switch (errorCode) {
2591
2360
  default:
2592
2361
  parsedBody = parsedOutput.body;
2593
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2594
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2362
+ response = new __BaseException({
2363
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2364
+ $fault: "client",
2365
+ $metadata: deserializeMetadata(output),
2366
+ });
2367
+ throw __decorateServiceException(response, parsedBody.Error);
2595
2368
  }
2596
- message = response.message || response.Message || errorCode;
2597
- response.message = message;
2598
- delete response.Message;
2599
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2369
+ return [2];
2600
2370
  }
2601
2371
  });
2602
2372
  }); };
@@ -2619,16 +2389,16 @@ export var deserializeAws_queryExecuteChangeSetCommand = function (output, conte
2619
2389
  });
2620
2390
  }); };
2621
2391
  var deserializeAws_queryExecuteChangeSetCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2622
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, parsedBody, message;
2623
- var _g;
2624
- return __generator(this, function (_h) {
2625
- switch (_h.label) {
2392
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2393
+ var _c;
2394
+ return __generator(this, function (_d) {
2395
+ switch (_d.label) {
2626
2396
  case 0:
2627
2397
  _a = [__assign({}, output)];
2628
- _g = {};
2398
+ _c = {};
2629
2399
  return [4, parseBody(output.body, context)];
2630
2400
  case 1:
2631
- parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
2401
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2632
2402
  errorCode = "UnknownError";
2633
2403
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
2634
2404
  _b = errorCode;
@@ -2643,40 +2413,22 @@ var deserializeAws_queryExecuteChangeSetCommandError = function (output, context
2643
2413
  case "com.amazonaws.cloudformation#TokenAlreadyExistsException": return [3, 8];
2644
2414
  }
2645
2415
  return [3, 10];
2646
- case 2:
2647
- _c = [{}];
2648
- return [4, deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)];
2649
- case 3:
2650
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2651
- return [3, 11];
2652
- case 4:
2653
- _d = [{}];
2654
- return [4, deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)];
2655
- case 5:
2656
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2657
- return [3, 11];
2658
- case 6:
2659
- _e = [{}];
2660
- return [4, deserializeAws_queryInvalidChangeSetStatusExceptionResponse(parsedOutput, context)];
2661
- case 7:
2662
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2663
- return [3, 11];
2664
- case 8:
2665
- _f = [{}];
2666
- return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
2667
- case 9:
2668
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2669
- return [3, 11];
2416
+ case 2: return [4, deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)];
2417
+ case 3: throw _d.sent();
2418
+ case 4: return [4, deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)];
2419
+ case 5: throw _d.sent();
2420
+ case 6: return [4, deserializeAws_queryInvalidChangeSetStatusExceptionResponse(parsedOutput, context)];
2421
+ case 7: throw _d.sent();
2422
+ case 8: return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
2423
+ case 9: throw _d.sent();
2670
2424
  case 10:
2671
2425
  parsedBody = parsedOutput.body;
2672
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2673
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2674
- _h.label = 11;
2675
- case 11:
2676
- message = response.message || response.Message || errorCode;
2677
- response.message = message;
2678
- delete response.Message;
2679
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2426
+ response = new __BaseException({
2427
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2428
+ $fault: "client",
2429
+ $metadata: deserializeMetadata(output),
2430
+ });
2431
+ throw __decorateServiceException(response, parsedBody.Error);
2680
2432
  }
2681
2433
  });
2682
2434
  }); };
@@ -2699,7 +2451,7 @@ export var deserializeAws_queryGetStackPolicyCommand = function (output, context
2699
2451
  });
2700
2452
  }); };
2701
2453
  var deserializeAws_queryGetStackPolicyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2702
- var parsedOutput, _a, response, errorCode, parsedBody, message;
2454
+ var parsedOutput, _a, response, errorCode, parsedBody;
2703
2455
  var _b;
2704
2456
  return __generator(this, function (_c) {
2705
2457
  switch (_c.label) {
@@ -2714,13 +2466,14 @@ var deserializeAws_queryGetStackPolicyCommandError = function (output, context)
2714
2466
  switch (errorCode) {
2715
2467
  default:
2716
2468
  parsedBody = parsedOutput.body;
2717
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2718
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2469
+ response = new __BaseException({
2470
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2471
+ $fault: "client",
2472
+ $metadata: deserializeMetadata(output),
2473
+ });
2474
+ throw __decorateServiceException(response, parsedBody.Error);
2719
2475
  }
2720
- message = response.message || response.Message || errorCode;
2721
- response.message = message;
2722
- delete response.Message;
2723
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2476
+ return [2];
2724
2477
  }
2725
2478
  });
2726
2479
  }); };
@@ -2743,16 +2496,16 @@ export var deserializeAws_queryGetTemplateCommand = function (output, context) {
2743
2496
  });
2744
2497
  }); };
2745
2498
  var deserializeAws_queryGetTemplateCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2746
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
2747
- var _d;
2748
- return __generator(this, function (_e) {
2749
- switch (_e.label) {
2499
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2500
+ var _c;
2501
+ return __generator(this, function (_d) {
2502
+ switch (_d.label) {
2750
2503
  case 0:
2751
2504
  _a = [__assign({}, output)];
2752
- _d = {};
2505
+ _c = {};
2753
2506
  return [4, parseBody(output.body, context)];
2754
2507
  case 1:
2755
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
2508
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2756
2509
  errorCode = "UnknownError";
2757
2510
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
2758
2511
  _b = errorCode;
@@ -2761,22 +2514,16 @@ var deserializeAws_queryGetTemplateCommandError = function (output, context) { r
2761
2514
  case "com.amazonaws.cloudformation#ChangeSetNotFoundException": return [3, 2];
2762
2515
  }
2763
2516
  return [3, 4];
2764
- case 2:
2765
- _c = [{}];
2766
- return [4, deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)];
2767
- case 3:
2768
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2769
- return [3, 5];
2517
+ case 2: return [4, deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)];
2518
+ case 3: throw _d.sent();
2770
2519
  case 4:
2771
2520
  parsedBody = parsedOutput.body;
2772
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2773
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2774
- _e.label = 5;
2775
- case 5:
2776
- message = response.message || response.Message || errorCode;
2777
- response.message = message;
2778
- delete response.Message;
2779
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2521
+ response = new __BaseException({
2522
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2523
+ $fault: "client",
2524
+ $metadata: deserializeMetadata(output),
2525
+ });
2526
+ throw __decorateServiceException(response, parsedBody.Error);
2780
2527
  }
2781
2528
  });
2782
2529
  }); };
@@ -2799,16 +2546,16 @@ export var deserializeAws_queryGetTemplateSummaryCommand = function (output, con
2799
2546
  });
2800
2547
  }); };
2801
2548
  var deserializeAws_queryGetTemplateSummaryCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2802
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
2803
- var _d;
2804
- return __generator(this, function (_e) {
2805
- switch (_e.label) {
2549
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2550
+ var _c;
2551
+ return __generator(this, function (_d) {
2552
+ switch (_d.label) {
2806
2553
  case 0:
2807
2554
  _a = [__assign({}, output)];
2808
- _d = {};
2555
+ _c = {};
2809
2556
  return [4, parseBody(output.body, context)];
2810
2557
  case 1:
2811
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
2558
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2812
2559
  errorCode = "UnknownError";
2813
2560
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
2814
2561
  _b = errorCode;
@@ -2817,22 +2564,16 @@ var deserializeAws_queryGetTemplateSummaryCommandError = function (output, conte
2817
2564
  case "com.amazonaws.cloudformation#StackSetNotFoundException": return [3, 2];
2818
2565
  }
2819
2566
  return [3, 4];
2820
- case 2:
2821
- _c = [{}];
2822
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2823
- case 3:
2824
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2825
- return [3, 5];
2567
+ case 2: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2568
+ case 3: throw _d.sent();
2826
2569
  case 4:
2827
2570
  parsedBody = parsedOutput.body;
2828
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2829
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2830
- _e.label = 5;
2831
- case 5:
2832
- message = response.message || response.Message || errorCode;
2833
- response.message = message;
2834
- delete response.Message;
2835
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2571
+ response = new __BaseException({
2572
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2573
+ $fault: "client",
2574
+ $metadata: deserializeMetadata(output),
2575
+ });
2576
+ throw __decorateServiceException(response, parsedBody.Error);
2836
2577
  }
2837
2578
  });
2838
2579
  }); };
@@ -2855,16 +2596,16 @@ export var deserializeAws_queryImportStacksToStackSetCommand = function (output,
2855
2596
  });
2856
2597
  }); };
2857
2598
  var deserializeAws_queryImportStacksToStackSetCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2858
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, _h, _j, parsedBody, message;
2859
- var _k;
2860
- return __generator(this, function (_l) {
2861
- switch (_l.label) {
2599
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2600
+ var _c;
2601
+ return __generator(this, function (_d) {
2602
+ switch (_d.label) {
2862
2603
  case 0:
2863
2604
  _a = [__assign({}, output)];
2864
- _k = {};
2605
+ _c = {};
2865
2606
  return [4, parseBody(output.body, context)];
2866
2607
  case 1:
2867
- parsedOutput = __assign.apply(void 0, _a.concat([(_k.body = _l.sent(), _k)]));
2608
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
2868
2609
  errorCode = "UnknownError";
2869
2610
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
2870
2611
  _b = errorCode;
@@ -2885,58 +2626,28 @@ var deserializeAws_queryImportStacksToStackSetCommandError = function (output, c
2885
2626
  case "com.amazonaws.cloudformation#StaleRequestException": return [3, 14];
2886
2627
  }
2887
2628
  return [3, 16];
2888
- case 2:
2889
- _c = [{}];
2890
- return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
2891
- case 3:
2892
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_l.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2893
- return [3, 17];
2894
- case 4:
2895
- _d = [{}];
2896
- return [4, deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)];
2897
- case 5:
2898
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_l.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2899
- return [3, 17];
2900
- case 6:
2901
- _e = [{}];
2902
- return [4, deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)];
2903
- case 7:
2904
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_l.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2905
- return [3, 17];
2906
- case 8:
2907
- _f = [{}];
2908
- return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
2909
- case 9:
2910
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_l.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2911
- return [3, 17];
2912
- case 10:
2913
- _g = [{}];
2914
- return [4, deserializeAws_queryStackNotFoundExceptionResponse(parsedOutput, context)];
2915
- case 11:
2916
- response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_l.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2917
- return [3, 17];
2918
- case 12:
2919
- _h = [{}];
2920
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2921
- case 13:
2922
- response = __assign.apply(void 0, [__assign.apply(void 0, _h.concat([(_l.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2923
- return [3, 17];
2924
- case 14:
2925
- _j = [{}];
2926
- return [4, deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)];
2927
- case 15:
2928
- response = __assign.apply(void 0, [__assign.apply(void 0, _j.concat([(_l.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
2929
- return [3, 17];
2629
+ case 2: return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
2630
+ case 3: throw _d.sent();
2631
+ case 4: return [4, deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)];
2632
+ case 5: throw _d.sent();
2633
+ case 6: return [4, deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)];
2634
+ case 7: throw _d.sent();
2635
+ case 8: return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
2636
+ case 9: throw _d.sent();
2637
+ case 10: return [4, deserializeAws_queryStackNotFoundExceptionResponse(parsedOutput, context)];
2638
+ case 11: throw _d.sent();
2639
+ case 12: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2640
+ case 13: throw _d.sent();
2641
+ case 14: return [4, deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)];
2642
+ case 15: throw _d.sent();
2930
2643
  case 16:
2931
2644
  parsedBody = parsedOutput.body;
2932
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2933
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2934
- _l.label = 17;
2935
- case 17:
2936
- message = response.message || response.Message || errorCode;
2937
- response.message = message;
2938
- delete response.Message;
2939
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2645
+ response = new __BaseException({
2646
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2647
+ $fault: "client",
2648
+ $metadata: deserializeMetadata(output),
2649
+ });
2650
+ throw __decorateServiceException(response, parsedBody.Error);
2940
2651
  }
2941
2652
  });
2942
2653
  }); };
@@ -2959,7 +2670,7 @@ export var deserializeAws_queryListChangeSetsCommand = function (output, context
2959
2670
  });
2960
2671
  }); };
2961
2672
  var deserializeAws_queryListChangeSetsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
2962
- var parsedOutput, _a, response, errorCode, parsedBody, message;
2673
+ var parsedOutput, _a, response, errorCode, parsedBody;
2963
2674
  var _b;
2964
2675
  return __generator(this, function (_c) {
2965
2676
  switch (_c.label) {
@@ -2974,13 +2685,14 @@ var deserializeAws_queryListChangeSetsCommandError = function (output, context)
2974
2685
  switch (errorCode) {
2975
2686
  default:
2976
2687
  parsedBody = parsedOutput.body;
2977
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2978
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2688
+ response = new __BaseException({
2689
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2690
+ $fault: "client",
2691
+ $metadata: deserializeMetadata(output),
2692
+ });
2693
+ throw __decorateServiceException(response, parsedBody.Error);
2979
2694
  }
2980
- message = response.message || response.Message || errorCode;
2981
- response.message = message;
2982
- delete response.Message;
2983
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2695
+ return [2];
2984
2696
  }
2985
2697
  });
2986
2698
  }); };
@@ -3003,7 +2715,7 @@ export var deserializeAws_queryListExportsCommand = function (output, context) {
3003
2715
  });
3004
2716
  }); };
3005
2717
  var deserializeAws_queryListExportsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3006
- var parsedOutput, _a, response, errorCode, parsedBody, message;
2718
+ var parsedOutput, _a, response, errorCode, parsedBody;
3007
2719
  var _b;
3008
2720
  return __generator(this, function (_c) {
3009
2721
  switch (_c.label) {
@@ -3018,13 +2730,14 @@ var deserializeAws_queryListExportsCommandError = function (output, context) { r
3018
2730
  switch (errorCode) {
3019
2731
  default:
3020
2732
  parsedBody = parsedOutput.body;
3021
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3022
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2733
+ response = new __BaseException({
2734
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2735
+ $fault: "client",
2736
+ $metadata: deserializeMetadata(output),
2737
+ });
2738
+ throw __decorateServiceException(response, parsedBody.Error);
3023
2739
  }
3024
- message = response.message || response.Message || errorCode;
3025
- response.message = message;
3026
- delete response.Message;
3027
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2740
+ return [2];
3028
2741
  }
3029
2742
  });
3030
2743
  }); };
@@ -3047,7 +2760,7 @@ export var deserializeAws_queryListImportsCommand = function (output, context) {
3047
2760
  });
3048
2761
  }); };
3049
2762
  var deserializeAws_queryListImportsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3050
- var parsedOutput, _a, response, errorCode, parsedBody, message;
2763
+ var parsedOutput, _a, response, errorCode, parsedBody;
3051
2764
  var _b;
3052
2765
  return __generator(this, function (_c) {
3053
2766
  switch (_c.label) {
@@ -3062,13 +2775,14 @@ var deserializeAws_queryListImportsCommandError = function (output, context) { r
3062
2775
  switch (errorCode) {
3063
2776
  default:
3064
2777
  parsedBody = parsedOutput.body;
3065
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3066
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2778
+ response = new __BaseException({
2779
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2780
+ $fault: "client",
2781
+ $metadata: deserializeMetadata(output),
2782
+ });
2783
+ throw __decorateServiceException(response, parsedBody.Error);
3067
2784
  }
3068
- message = response.message || response.Message || errorCode;
3069
- response.message = message;
3070
- delete response.Message;
3071
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2785
+ return [2];
3072
2786
  }
3073
2787
  });
3074
2788
  }); };
@@ -3091,16 +2805,16 @@ export var deserializeAws_queryListStackInstancesCommand = function (output, con
3091
2805
  });
3092
2806
  }); };
3093
2807
  var deserializeAws_queryListStackInstancesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3094
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
3095
- var _d;
3096
- return __generator(this, function (_e) {
3097
- switch (_e.label) {
2808
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2809
+ var _c;
2810
+ return __generator(this, function (_d) {
2811
+ switch (_d.label) {
3098
2812
  case 0:
3099
2813
  _a = [__assign({}, output)];
3100
- _d = {};
2814
+ _c = {};
3101
2815
  return [4, parseBody(output.body, context)];
3102
2816
  case 1:
3103
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
2817
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3104
2818
  errorCode = "UnknownError";
3105
2819
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3106
2820
  _b = errorCode;
@@ -3109,22 +2823,16 @@ var deserializeAws_queryListStackInstancesCommandError = function (output, conte
3109
2823
  case "com.amazonaws.cloudformation#StackSetNotFoundException": return [3, 2];
3110
2824
  }
3111
2825
  return [3, 4];
3112
- case 2:
3113
- _c = [{}];
3114
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
3115
- case 3:
3116
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3117
- return [3, 5];
2826
+ case 2: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2827
+ case 3: throw _d.sent();
3118
2828
  case 4:
3119
2829
  parsedBody = parsedOutput.body;
3120
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3121
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3122
- _e.label = 5;
3123
- case 5:
3124
- message = response.message || response.Message || errorCode;
3125
- response.message = message;
3126
- delete response.Message;
3127
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2830
+ response = new __BaseException({
2831
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2832
+ $fault: "client",
2833
+ $metadata: deserializeMetadata(output),
2834
+ });
2835
+ throw __decorateServiceException(response, parsedBody.Error);
3128
2836
  }
3129
2837
  });
3130
2838
  }); };
@@ -3147,7 +2855,7 @@ export var deserializeAws_queryListStackResourcesCommand = function (output, con
3147
2855
  });
3148
2856
  }); };
3149
2857
  var deserializeAws_queryListStackResourcesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3150
- var parsedOutput, _a, response, errorCode, parsedBody, message;
2858
+ var parsedOutput, _a, response, errorCode, parsedBody;
3151
2859
  var _b;
3152
2860
  return __generator(this, function (_c) {
3153
2861
  switch (_c.label) {
@@ -3162,13 +2870,14 @@ var deserializeAws_queryListStackResourcesCommandError = function (output, conte
3162
2870
  switch (errorCode) {
3163
2871
  default:
3164
2872
  parsedBody = parsedOutput.body;
3165
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3166
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2873
+ response = new __BaseException({
2874
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2875
+ $fault: "client",
2876
+ $metadata: deserializeMetadata(output),
2877
+ });
2878
+ throw __decorateServiceException(response, parsedBody.Error);
3167
2879
  }
3168
- message = response.message || response.Message || errorCode;
3169
- response.message = message;
3170
- delete response.Message;
3171
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2880
+ return [2];
3172
2881
  }
3173
2882
  });
3174
2883
  }); };
@@ -3191,7 +2900,7 @@ export var deserializeAws_queryListStacksCommand = function (output, context) {
3191
2900
  });
3192
2901
  }); };
3193
2902
  var deserializeAws_queryListStacksCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3194
- var parsedOutput, _a, response, errorCode, parsedBody, message;
2903
+ var parsedOutput, _a, response, errorCode, parsedBody;
3195
2904
  var _b;
3196
2905
  return __generator(this, function (_c) {
3197
2906
  switch (_c.label) {
@@ -3206,13 +2915,14 @@ var deserializeAws_queryListStacksCommandError = function (output, context) { re
3206
2915
  switch (errorCode) {
3207
2916
  default:
3208
2917
  parsedBody = parsedOutput.body;
3209
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3210
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
2918
+ response = new __BaseException({
2919
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2920
+ $fault: "client",
2921
+ $metadata: deserializeMetadata(output),
2922
+ });
2923
+ throw __decorateServiceException(response, parsedBody.Error);
3211
2924
  }
3212
- message = response.message || response.Message || errorCode;
3213
- response.message = message;
3214
- delete response.Message;
3215
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2925
+ return [2];
3216
2926
  }
3217
2927
  });
3218
2928
  }); };
@@ -3235,16 +2945,16 @@ export var deserializeAws_queryListStackSetOperationResultsCommand = function (o
3235
2945
  });
3236
2946
  }); };
3237
2947
  var deserializeAws_queryListStackSetOperationResultsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3238
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
3239
- var _e;
3240
- return __generator(this, function (_f) {
3241
- switch (_f.label) {
2948
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
2949
+ var _c;
2950
+ return __generator(this, function (_d) {
2951
+ switch (_d.label) {
3242
2952
  case 0:
3243
2953
  _a = [__assign({}, output)];
3244
- _e = {};
2954
+ _c = {};
3245
2955
  return [4, parseBody(output.body, context)];
3246
2956
  case 1:
3247
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
2957
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3248
2958
  errorCode = "UnknownError";
3249
2959
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3250
2960
  _b = errorCode;
@@ -3255,28 +2965,18 @@ var deserializeAws_queryListStackSetOperationResultsCommandError = function (out
3255
2965
  case "com.amazonaws.cloudformation#StackSetNotFoundException": return [3, 4];
3256
2966
  }
3257
2967
  return [3, 6];
3258
- case 2:
3259
- _c = [{}];
3260
- return [4, deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context)];
3261
- case 3:
3262
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3263
- return [3, 7];
3264
- case 4:
3265
- _d = [{}];
3266
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
3267
- case 5:
3268
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3269
- return [3, 7];
2968
+ case 2: return [4, deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context)];
2969
+ case 3: throw _d.sent();
2970
+ case 4: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
2971
+ case 5: throw _d.sent();
3270
2972
  case 6:
3271
2973
  parsedBody = parsedOutput.body;
3272
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3273
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3274
- _f.label = 7;
3275
- case 7:
3276
- message = response.message || response.Message || errorCode;
3277
- response.message = message;
3278
- delete response.Message;
3279
- return [2, Promise.reject(Object.assign(new Error(message), response))];
2974
+ response = new __BaseException({
2975
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2976
+ $fault: "client",
2977
+ $metadata: deserializeMetadata(output),
2978
+ });
2979
+ throw __decorateServiceException(response, parsedBody.Error);
3280
2980
  }
3281
2981
  });
3282
2982
  }); };
@@ -3299,16 +2999,16 @@ export var deserializeAws_queryListStackSetOperationsCommand = function (output,
3299
2999
  });
3300
3000
  }); };
3301
3001
  var deserializeAws_queryListStackSetOperationsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3302
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
3303
- var _d;
3304
- return __generator(this, function (_e) {
3305
- switch (_e.label) {
3002
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3003
+ var _c;
3004
+ return __generator(this, function (_d) {
3005
+ switch (_d.label) {
3306
3006
  case 0:
3307
3007
  _a = [__assign({}, output)];
3308
- _d = {};
3008
+ _c = {};
3309
3009
  return [4, parseBody(output.body, context)];
3310
3010
  case 1:
3311
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
3011
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3312
3012
  errorCode = "UnknownError";
3313
3013
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3314
3014
  _b = errorCode;
@@ -3317,22 +3017,16 @@ var deserializeAws_queryListStackSetOperationsCommandError = function (output, c
3317
3017
  case "com.amazonaws.cloudformation#StackSetNotFoundException": return [3, 2];
3318
3018
  }
3319
3019
  return [3, 4];
3320
- case 2:
3321
- _c = [{}];
3322
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
3323
- case 3:
3324
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3325
- return [3, 5];
3020
+ case 2: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
3021
+ case 3: throw _d.sent();
3326
3022
  case 4:
3327
3023
  parsedBody = parsedOutput.body;
3328
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3329
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3330
- _e.label = 5;
3331
- case 5:
3332
- message = response.message || response.Message || errorCode;
3333
- response.message = message;
3334
- delete response.Message;
3335
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3024
+ response = new __BaseException({
3025
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3026
+ $fault: "client",
3027
+ $metadata: deserializeMetadata(output),
3028
+ });
3029
+ throw __decorateServiceException(response, parsedBody.Error);
3336
3030
  }
3337
3031
  });
3338
3032
  }); };
@@ -3355,7 +3049,7 @@ export var deserializeAws_queryListStackSetsCommand = function (output, context)
3355
3049
  });
3356
3050
  }); };
3357
3051
  var deserializeAws_queryListStackSetsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3358
- var parsedOutput, _a, response, errorCode, parsedBody, message;
3052
+ var parsedOutput, _a, response, errorCode, parsedBody;
3359
3053
  var _b;
3360
3054
  return __generator(this, function (_c) {
3361
3055
  switch (_c.label) {
@@ -3370,13 +3064,14 @@ var deserializeAws_queryListStackSetsCommandError = function (output, context) {
3370
3064
  switch (errorCode) {
3371
3065
  default:
3372
3066
  parsedBody = parsedOutput.body;
3373
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3374
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3067
+ response = new __BaseException({
3068
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3069
+ $fault: "client",
3070
+ $metadata: deserializeMetadata(output),
3071
+ });
3072
+ throw __decorateServiceException(response, parsedBody.Error);
3375
3073
  }
3376
- message = response.message || response.Message || errorCode;
3377
- response.message = message;
3378
- delete response.Message;
3379
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3074
+ return [2];
3380
3075
  }
3381
3076
  });
3382
3077
  }); };
@@ -3399,16 +3094,16 @@ export var deserializeAws_queryListTypeRegistrationsCommand = function (output,
3399
3094
  });
3400
3095
  }); };
3401
3096
  var deserializeAws_queryListTypeRegistrationsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3402
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
3403
- var _d;
3404
- return __generator(this, function (_e) {
3405
- switch (_e.label) {
3097
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3098
+ var _c;
3099
+ return __generator(this, function (_d) {
3100
+ switch (_d.label) {
3406
3101
  case 0:
3407
3102
  _a = [__assign({}, output)];
3408
- _d = {};
3103
+ _c = {};
3409
3104
  return [4, parseBody(output.body, context)];
3410
3105
  case 1:
3411
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
3106
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3412
3107
  errorCode = "UnknownError";
3413
3108
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3414
3109
  _b = errorCode;
@@ -3417,22 +3112,16 @@ var deserializeAws_queryListTypeRegistrationsCommandError = function (output, co
3417
3112
  case "com.amazonaws.cloudformation#CFNRegistryException": return [3, 2];
3418
3113
  }
3419
3114
  return [3, 4];
3420
- case 2:
3421
- _c = [{}];
3422
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3423
- case 3:
3424
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3425
- return [3, 5];
3115
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3116
+ case 3: throw _d.sent();
3426
3117
  case 4:
3427
3118
  parsedBody = parsedOutput.body;
3428
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3429
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3430
- _e.label = 5;
3431
- case 5:
3432
- message = response.message || response.Message || errorCode;
3433
- response.message = message;
3434
- delete response.Message;
3435
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3119
+ response = new __BaseException({
3120
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3121
+ $fault: "client",
3122
+ $metadata: deserializeMetadata(output),
3123
+ });
3124
+ throw __decorateServiceException(response, parsedBody.Error);
3436
3125
  }
3437
3126
  });
3438
3127
  }); };
@@ -3455,16 +3144,16 @@ export var deserializeAws_queryListTypesCommand = function (output, context) { r
3455
3144
  });
3456
3145
  }); };
3457
3146
  var deserializeAws_queryListTypesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3458
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
3459
- var _d;
3460
- return __generator(this, function (_e) {
3461
- switch (_e.label) {
3147
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3148
+ var _c;
3149
+ return __generator(this, function (_d) {
3150
+ switch (_d.label) {
3462
3151
  case 0:
3463
3152
  _a = [__assign({}, output)];
3464
- _d = {};
3153
+ _c = {};
3465
3154
  return [4, parseBody(output.body, context)];
3466
3155
  case 1:
3467
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
3156
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3468
3157
  errorCode = "UnknownError";
3469
3158
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3470
3159
  _b = errorCode;
@@ -3473,22 +3162,16 @@ var deserializeAws_queryListTypesCommandError = function (output, context) { ret
3473
3162
  case "com.amazonaws.cloudformation#CFNRegistryException": return [3, 2];
3474
3163
  }
3475
3164
  return [3, 4];
3476
- case 2:
3477
- _c = [{}];
3478
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3479
- case 3:
3480
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3481
- return [3, 5];
3165
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3166
+ case 3: throw _d.sent();
3482
3167
  case 4:
3483
3168
  parsedBody = parsedOutput.body;
3484
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3485
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3486
- _e.label = 5;
3487
- case 5:
3488
- message = response.message || response.Message || errorCode;
3489
- response.message = message;
3490
- delete response.Message;
3491
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3169
+ response = new __BaseException({
3170
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3171
+ $fault: "client",
3172
+ $metadata: deserializeMetadata(output),
3173
+ });
3174
+ throw __decorateServiceException(response, parsedBody.Error);
3492
3175
  }
3493
3176
  });
3494
3177
  }); };
@@ -3511,16 +3194,16 @@ export var deserializeAws_queryListTypeVersionsCommand = function (output, conte
3511
3194
  });
3512
3195
  }); };
3513
3196
  var deserializeAws_queryListTypeVersionsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3514
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
3515
- var _d;
3516
- return __generator(this, function (_e) {
3517
- switch (_e.label) {
3197
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3198
+ var _c;
3199
+ return __generator(this, function (_d) {
3200
+ switch (_d.label) {
3518
3201
  case 0:
3519
3202
  _a = [__assign({}, output)];
3520
- _d = {};
3203
+ _c = {};
3521
3204
  return [4, parseBody(output.body, context)];
3522
3205
  case 1:
3523
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
3206
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3524
3207
  errorCode = "UnknownError";
3525
3208
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3526
3209
  _b = errorCode;
@@ -3529,22 +3212,16 @@ var deserializeAws_queryListTypeVersionsCommandError = function (output, context
3529
3212
  case "com.amazonaws.cloudformation#CFNRegistryException": return [3, 2];
3530
3213
  }
3531
3214
  return [3, 4];
3532
- case 2:
3533
- _c = [{}];
3534
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3535
- case 3:
3536
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3537
- return [3, 5];
3215
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3216
+ case 3: throw _d.sent();
3538
3217
  case 4:
3539
3218
  parsedBody = parsedOutput.body;
3540
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3541
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3542
- _e.label = 5;
3543
- case 5:
3544
- message = response.message || response.Message || errorCode;
3545
- response.message = message;
3546
- delete response.Message;
3547
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3219
+ response = new __BaseException({
3220
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3221
+ $fault: "client",
3222
+ $metadata: deserializeMetadata(output),
3223
+ });
3224
+ throw __decorateServiceException(response, parsedBody.Error);
3548
3225
  }
3549
3226
  });
3550
3227
  }); };
@@ -3567,16 +3244,16 @@ export var deserializeAws_queryPublishTypeCommand = function (output, context) {
3567
3244
  });
3568
3245
  }); };
3569
3246
  var deserializeAws_queryPublishTypeCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3570
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
3571
- var _e;
3572
- return __generator(this, function (_f) {
3573
- switch (_f.label) {
3247
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3248
+ var _c;
3249
+ return __generator(this, function (_d) {
3250
+ switch (_d.label) {
3574
3251
  case 0:
3575
3252
  _a = [__assign({}, output)];
3576
- _e = {};
3253
+ _c = {};
3577
3254
  return [4, parseBody(output.body, context)];
3578
3255
  case 1:
3579
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
3256
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3580
3257
  errorCode = "UnknownError";
3581
3258
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3582
3259
  _b = errorCode;
@@ -3587,28 +3264,18 @@ var deserializeAws_queryPublishTypeCommandError = function (output, context) { r
3587
3264
  case "com.amazonaws.cloudformation#TypeNotFoundException": return [3, 4];
3588
3265
  }
3589
3266
  return [3, 6];
3590
- case 2:
3591
- _c = [{}];
3592
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3593
- case 3:
3594
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3595
- return [3, 7];
3596
- case 4:
3597
- _d = [{}];
3598
- return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
3599
- case 5:
3600
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3601
- return [3, 7];
3267
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3268
+ case 3: throw _d.sent();
3269
+ case 4: return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
3270
+ case 5: throw _d.sent();
3602
3271
  case 6:
3603
3272
  parsedBody = parsedOutput.body;
3604
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3605
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3606
- _f.label = 7;
3607
- case 7:
3608
- message = response.message || response.Message || errorCode;
3609
- response.message = message;
3610
- delete response.Message;
3611
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3273
+ response = new __BaseException({
3274
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3275
+ $fault: "client",
3276
+ $metadata: deserializeMetadata(output),
3277
+ });
3278
+ throw __decorateServiceException(response, parsedBody.Error);
3612
3279
  }
3613
3280
  });
3614
3281
  }); };
@@ -3631,16 +3298,16 @@ export var deserializeAws_queryRecordHandlerProgressCommand = function (output,
3631
3298
  });
3632
3299
  }); };
3633
3300
  var deserializeAws_queryRecordHandlerProgressCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3634
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
3635
- var _e;
3636
- return __generator(this, function (_f) {
3637
- switch (_f.label) {
3301
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3302
+ var _c;
3303
+ return __generator(this, function (_d) {
3304
+ switch (_d.label) {
3638
3305
  case 0:
3639
3306
  _a = [__assign({}, output)];
3640
- _e = {};
3307
+ _c = {};
3641
3308
  return [4, parseBody(output.body, context)];
3642
3309
  case 1:
3643
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
3310
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3644
3311
  errorCode = "UnknownError";
3645
3312
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3646
3313
  _b = errorCode;
@@ -3651,28 +3318,18 @@ var deserializeAws_queryRecordHandlerProgressCommandError = function (output, co
3651
3318
  case "com.amazonaws.cloudformation#OperationStatusCheckFailedException": return [3, 4];
3652
3319
  }
3653
3320
  return [3, 6];
3654
- case 2:
3655
- _c = [{}];
3656
- return [4, deserializeAws_queryInvalidStateTransitionExceptionResponse(parsedOutput, context)];
3657
- case 3:
3658
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3659
- return [3, 7];
3660
- case 4:
3661
- _d = [{}];
3662
- return [4, deserializeAws_queryOperationStatusCheckFailedExceptionResponse(parsedOutput, context)];
3663
- case 5:
3664
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3665
- return [3, 7];
3321
+ case 2: return [4, deserializeAws_queryInvalidStateTransitionExceptionResponse(parsedOutput, context)];
3322
+ case 3: throw _d.sent();
3323
+ case 4: return [4, deserializeAws_queryOperationStatusCheckFailedExceptionResponse(parsedOutput, context)];
3324
+ case 5: throw _d.sent();
3666
3325
  case 6:
3667
3326
  parsedBody = parsedOutput.body;
3668
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3669
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3670
- _f.label = 7;
3671
- case 7:
3672
- message = response.message || response.Message || errorCode;
3673
- response.message = message;
3674
- delete response.Message;
3675
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3327
+ response = new __BaseException({
3328
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3329
+ $fault: "client",
3330
+ $metadata: deserializeMetadata(output),
3331
+ });
3332
+ throw __decorateServiceException(response, parsedBody.Error);
3676
3333
  }
3677
3334
  });
3678
3335
  }); };
@@ -3695,16 +3352,16 @@ export var deserializeAws_queryRegisterPublisherCommand = function (output, cont
3695
3352
  });
3696
3353
  }); };
3697
3354
  var deserializeAws_queryRegisterPublisherCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3698
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
3699
- var _d;
3700
- return __generator(this, function (_e) {
3701
- switch (_e.label) {
3355
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3356
+ var _c;
3357
+ return __generator(this, function (_d) {
3358
+ switch (_d.label) {
3702
3359
  case 0:
3703
3360
  _a = [__assign({}, output)];
3704
- _d = {};
3361
+ _c = {};
3705
3362
  return [4, parseBody(output.body, context)];
3706
3363
  case 1:
3707
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
3364
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3708
3365
  errorCode = "UnknownError";
3709
3366
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3710
3367
  _b = errorCode;
@@ -3713,22 +3370,16 @@ var deserializeAws_queryRegisterPublisherCommandError = function (output, contex
3713
3370
  case "com.amazonaws.cloudformation#CFNRegistryException": return [3, 2];
3714
3371
  }
3715
3372
  return [3, 4];
3716
- case 2:
3717
- _c = [{}];
3718
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3719
- case 3:
3720
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3721
- return [3, 5];
3373
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3374
+ case 3: throw _d.sent();
3722
3375
  case 4:
3723
3376
  parsedBody = parsedOutput.body;
3724
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3725
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3726
- _e.label = 5;
3727
- case 5:
3728
- message = response.message || response.Message || errorCode;
3729
- response.message = message;
3730
- delete response.Message;
3731
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3377
+ response = new __BaseException({
3378
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3379
+ $fault: "client",
3380
+ $metadata: deserializeMetadata(output),
3381
+ });
3382
+ throw __decorateServiceException(response, parsedBody.Error);
3732
3383
  }
3733
3384
  });
3734
3385
  }); };
@@ -3751,16 +3402,16 @@ export var deserializeAws_queryRegisterTypeCommand = function (output, context)
3751
3402
  });
3752
3403
  }); };
3753
3404
  var deserializeAws_queryRegisterTypeCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3754
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
3755
- var _d;
3756
- return __generator(this, function (_e) {
3757
- switch (_e.label) {
3405
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3406
+ var _c;
3407
+ return __generator(this, function (_d) {
3408
+ switch (_d.label) {
3758
3409
  case 0:
3759
3410
  _a = [__assign({}, output)];
3760
- _d = {};
3411
+ _c = {};
3761
3412
  return [4, parseBody(output.body, context)];
3762
3413
  case 1:
3763
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
3414
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3764
3415
  errorCode = "UnknownError";
3765
3416
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3766
3417
  _b = errorCode;
@@ -3769,22 +3420,16 @@ var deserializeAws_queryRegisterTypeCommandError = function (output, context) {
3769
3420
  case "com.amazonaws.cloudformation#CFNRegistryException": return [3, 2];
3770
3421
  }
3771
3422
  return [3, 4];
3772
- case 2:
3773
- _c = [{}];
3774
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3775
- case 3:
3776
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3777
- return [3, 5];
3423
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3424
+ case 3: throw _d.sent();
3778
3425
  case 4:
3779
3426
  parsedBody = parsedOutput.body;
3780
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3781
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3782
- _e.label = 5;
3783
- case 5:
3784
- message = response.message || response.Message || errorCode;
3785
- response.message = message;
3786
- delete response.Message;
3787
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3427
+ response = new __BaseException({
3428
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3429
+ $fault: "client",
3430
+ $metadata: deserializeMetadata(output),
3431
+ });
3432
+ throw __decorateServiceException(response, parsedBody.Error);
3788
3433
  }
3789
3434
  });
3790
3435
  }); };
@@ -3807,16 +3452,16 @@ export var deserializeAws_queryRollbackStackCommand = function (output, context)
3807
3452
  });
3808
3453
  }); };
3809
3454
  var deserializeAws_queryRollbackStackCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3810
- var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
3811
- var _d;
3812
- return __generator(this, function (_e) {
3813
- switch (_e.label) {
3455
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3456
+ var _c;
3457
+ return __generator(this, function (_d) {
3458
+ switch (_d.label) {
3814
3459
  case 0:
3815
3460
  _a = [__assign({}, output)];
3816
- _d = {};
3461
+ _c = {};
3817
3462
  return [4, parseBody(output.body, context)];
3818
3463
  case 1:
3819
- parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
3464
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3820
3465
  errorCode = "UnknownError";
3821
3466
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3822
3467
  _b = errorCode;
@@ -3825,22 +3470,16 @@ var deserializeAws_queryRollbackStackCommandError = function (output, context) {
3825
3470
  case "com.amazonaws.cloudformation#TokenAlreadyExistsException": return [3, 2];
3826
3471
  }
3827
3472
  return [3, 4];
3828
- case 2:
3829
- _c = [{}];
3830
- return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
3831
- case 3:
3832
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3833
- return [3, 5];
3473
+ case 2: return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
3474
+ case 3: throw _d.sent();
3834
3475
  case 4:
3835
3476
  parsedBody = parsedOutput.body;
3836
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3837
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3838
- _e.label = 5;
3839
- case 5:
3840
- message = response.message || response.Message || errorCode;
3841
- response.message = message;
3842
- delete response.Message;
3843
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3477
+ response = new __BaseException({
3478
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3479
+ $fault: "client",
3480
+ $metadata: deserializeMetadata(output),
3481
+ });
3482
+ throw __decorateServiceException(response, parsedBody.Error);
3844
3483
  }
3845
3484
  });
3846
3485
  }); };
@@ -3863,7 +3502,7 @@ export var deserializeAws_querySetStackPolicyCommand = function (output, context
3863
3502
  });
3864
3503
  }); };
3865
3504
  var deserializeAws_querySetStackPolicyCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3866
- var parsedOutput, _a, response, errorCode, parsedBody, message;
3505
+ var parsedOutput, _a, response, errorCode, parsedBody;
3867
3506
  var _b;
3868
3507
  return __generator(this, function (_c) {
3869
3508
  switch (_c.label) {
@@ -3878,13 +3517,14 @@ var deserializeAws_querySetStackPolicyCommandError = function (output, context)
3878
3517
  switch (errorCode) {
3879
3518
  default:
3880
3519
  parsedBody = parsedOutput.body;
3881
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3882
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3520
+ response = new __BaseException({
3521
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3522
+ $fault: "client",
3523
+ $metadata: deserializeMetadata(output),
3524
+ });
3525
+ throw __decorateServiceException(response, parsedBody.Error);
3883
3526
  }
3884
- message = response.message || response.Message || errorCode;
3885
- response.message = message;
3886
- delete response.Message;
3887
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3527
+ return [2];
3888
3528
  }
3889
3529
  });
3890
3530
  }); };
@@ -3907,16 +3547,16 @@ export var deserializeAws_querySetTypeConfigurationCommand = function (output, c
3907
3547
  });
3908
3548
  }); };
3909
3549
  var deserializeAws_querySetTypeConfigurationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3910
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
3911
- var _e;
3912
- return __generator(this, function (_f) {
3913
- switch (_f.label) {
3550
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3551
+ var _c;
3552
+ return __generator(this, function (_d) {
3553
+ switch (_d.label) {
3914
3554
  case 0:
3915
3555
  _a = [__assign({}, output)];
3916
- _e = {};
3556
+ _c = {};
3917
3557
  return [4, parseBody(output.body, context)];
3918
3558
  case 1:
3919
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
3559
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3920
3560
  errorCode = "UnknownError";
3921
3561
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3922
3562
  _b = errorCode;
@@ -3927,28 +3567,18 @@ var deserializeAws_querySetTypeConfigurationCommandError = function (output, con
3927
3567
  case "com.amazonaws.cloudformation#TypeNotFoundException": return [3, 4];
3928
3568
  }
3929
3569
  return [3, 6];
3930
- case 2:
3931
- _c = [{}];
3932
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3933
- case 3:
3934
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3935
- return [3, 7];
3936
- case 4:
3937
- _d = [{}];
3938
- return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
3939
- case 5:
3940
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3941
- return [3, 7];
3570
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3571
+ case 3: throw _d.sent();
3572
+ case 4: return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
3573
+ case 5: throw _d.sent();
3942
3574
  case 6:
3943
3575
  parsedBody = parsedOutput.body;
3944
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
3945
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3946
- _f.label = 7;
3947
- case 7:
3948
- message = response.message || response.Message || errorCode;
3949
- response.message = message;
3950
- delete response.Message;
3951
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3576
+ response = new __BaseException({
3577
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3578
+ $fault: "client",
3579
+ $metadata: deserializeMetadata(output),
3580
+ });
3581
+ throw __decorateServiceException(response, parsedBody.Error);
3952
3582
  }
3953
3583
  });
3954
3584
  }); };
@@ -3971,16 +3601,16 @@ export var deserializeAws_querySetTypeDefaultVersionCommand = function (output,
3971
3601
  });
3972
3602
  }); };
3973
3603
  var deserializeAws_querySetTypeDefaultVersionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
3974
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
3975
- var _e;
3976
- return __generator(this, function (_f) {
3977
- switch (_f.label) {
3604
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3605
+ var _c;
3606
+ return __generator(this, function (_d) {
3607
+ switch (_d.label) {
3978
3608
  case 0:
3979
3609
  _a = [__assign({}, output)];
3980
- _e = {};
3610
+ _c = {};
3981
3611
  return [4, parseBody(output.body, context)];
3982
3612
  case 1:
3983
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
3613
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
3984
3614
  errorCode = "UnknownError";
3985
3615
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
3986
3616
  _b = errorCode;
@@ -3991,28 +3621,18 @@ var deserializeAws_querySetTypeDefaultVersionCommandError = function (output, co
3991
3621
  case "com.amazonaws.cloudformation#TypeNotFoundException": return [3, 4];
3992
3622
  }
3993
3623
  return [3, 6];
3994
- case 2:
3995
- _c = [{}];
3996
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3997
- case 3:
3998
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
3999
- return [3, 7];
4000
- case 4:
4001
- _d = [{}];
4002
- return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
4003
- case 5:
4004
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4005
- return [3, 7];
3624
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3625
+ case 3: throw _d.sent();
3626
+ case 4: return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
3627
+ case 5: throw _d.sent();
4006
3628
  case 6:
4007
3629
  parsedBody = parsedOutput.body;
4008
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
4009
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
4010
- _f.label = 7;
4011
- case 7:
4012
- message = response.message || response.Message || errorCode;
4013
- response.message = message;
4014
- delete response.Message;
4015
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3630
+ response = new __BaseException({
3631
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3632
+ $fault: "client",
3633
+ $metadata: deserializeMetadata(output),
3634
+ });
3635
+ throw __decorateServiceException(response, parsedBody.Error);
4016
3636
  }
4017
3637
  });
4018
3638
  }); };
@@ -4035,7 +3655,7 @@ export var deserializeAws_querySignalResourceCommand = function (output, context
4035
3655
  });
4036
3656
  }); };
4037
3657
  var deserializeAws_querySignalResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
4038
- var parsedOutput, _a, response, errorCode, parsedBody, message;
3658
+ var parsedOutput, _a, response, errorCode, parsedBody;
4039
3659
  var _b;
4040
3660
  return __generator(this, function (_c) {
4041
3661
  switch (_c.label) {
@@ -4050,13 +3670,14 @@ var deserializeAws_querySignalResourceCommandError = function (output, context)
4050
3670
  switch (errorCode) {
4051
3671
  default:
4052
3672
  parsedBody = parsedOutput.body;
4053
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
4054
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
3673
+ response = new __BaseException({
3674
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3675
+ $fault: "client",
3676
+ $metadata: deserializeMetadata(output),
3677
+ });
3678
+ throw __decorateServiceException(response, parsedBody.Error);
4055
3679
  }
4056
- message = response.message || response.Message || errorCode;
4057
- response.message = message;
4058
- delete response.Message;
4059
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3680
+ return [2];
4060
3681
  }
4061
3682
  });
4062
3683
  }); };
@@ -4079,16 +3700,16 @@ export var deserializeAws_queryStopStackSetOperationCommand = function (output,
4079
3700
  });
4080
3701
  }); };
4081
3702
  var deserializeAws_queryStopStackSetOperationCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
4082
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, parsedBody, message;
4083
- var _f;
4084
- return __generator(this, function (_g) {
4085
- switch (_g.label) {
3703
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3704
+ var _c;
3705
+ return __generator(this, function (_d) {
3706
+ switch (_d.label) {
4086
3707
  case 0:
4087
3708
  _a = [__assign({}, output)];
4088
- _f = {};
3709
+ _c = {};
4089
3710
  return [4, parseBody(output.body, context)];
4090
3711
  case 1:
4091
- parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
3712
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
4092
3713
  errorCode = "UnknownError";
4093
3714
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
4094
3715
  _b = errorCode;
@@ -4101,34 +3722,20 @@ var deserializeAws_queryStopStackSetOperationCommandError = function (output, co
4101
3722
  case "com.amazonaws.cloudformation#StackSetNotFoundException": return [3, 6];
4102
3723
  }
4103
3724
  return [3, 8];
4104
- case 2:
4105
- _c = [{}];
4106
- return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
4107
- case 3:
4108
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4109
- return [3, 9];
4110
- case 4:
4111
- _d = [{}];
4112
- return [4, deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context)];
4113
- case 5:
4114
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4115
- return [3, 9];
4116
- case 6:
4117
- _e = [{}];
4118
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
4119
- case 7:
4120
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4121
- return [3, 9];
3725
+ case 2: return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
3726
+ case 3: throw _d.sent();
3727
+ case 4: return [4, deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context)];
3728
+ case 5: throw _d.sent();
3729
+ case 6: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
3730
+ case 7: throw _d.sent();
4122
3731
  case 8:
4123
3732
  parsedBody = parsedOutput.body;
4124
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
4125
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
4126
- _g.label = 9;
4127
- case 9:
4128
- message = response.message || response.Message || errorCode;
4129
- response.message = message;
4130
- delete response.Message;
4131
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3733
+ response = new __BaseException({
3734
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3735
+ $fault: "client",
3736
+ $metadata: deserializeMetadata(output),
3737
+ });
3738
+ throw __decorateServiceException(response, parsedBody.Error);
4132
3739
  }
4133
3740
  });
4134
3741
  }); };
@@ -4151,16 +3758,16 @@ export var deserializeAws_queryTestTypeCommand = function (output, context) { re
4151
3758
  });
4152
3759
  }); };
4153
3760
  var deserializeAws_queryTestTypeCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
4154
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
4155
- var _e;
4156
- return __generator(this, function (_f) {
4157
- switch (_f.label) {
3761
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3762
+ var _c;
3763
+ return __generator(this, function (_d) {
3764
+ switch (_d.label) {
4158
3765
  case 0:
4159
3766
  _a = [__assign({}, output)];
4160
- _e = {};
3767
+ _c = {};
4161
3768
  return [4, parseBody(output.body, context)];
4162
3769
  case 1:
4163
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
3770
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
4164
3771
  errorCode = "UnknownError";
4165
3772
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
4166
3773
  _b = errorCode;
@@ -4171,28 +3778,18 @@ var deserializeAws_queryTestTypeCommandError = function (output, context) { retu
4171
3778
  case "com.amazonaws.cloudformation#TypeNotFoundException": return [3, 4];
4172
3779
  }
4173
3780
  return [3, 6];
4174
- case 2:
4175
- _c = [{}];
4176
- return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
4177
- case 3:
4178
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4179
- return [3, 7];
4180
- case 4:
4181
- _d = [{}];
4182
- return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
4183
- case 5:
4184
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4185
- return [3, 7];
3781
+ case 2: return [4, deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)];
3782
+ case 3: throw _d.sent();
3783
+ case 4: return [4, deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)];
3784
+ case 5: throw _d.sent();
4186
3785
  case 6:
4187
3786
  parsedBody = parsedOutput.body;
4188
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
4189
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
4190
- _f.label = 7;
4191
- case 7:
4192
- message = response.message || response.Message || errorCode;
4193
- response.message = message;
4194
- delete response.Message;
4195
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3787
+ response = new __BaseException({
3788
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3789
+ $fault: "client",
3790
+ $metadata: deserializeMetadata(output),
3791
+ });
3792
+ throw __decorateServiceException(response, parsedBody.Error);
4196
3793
  }
4197
3794
  });
4198
3795
  }); };
@@ -4215,16 +3812,16 @@ export var deserializeAws_queryUpdateStackCommand = function (output, context) {
4215
3812
  });
4216
3813
  }); };
4217
3814
  var deserializeAws_queryUpdateStackCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
4218
- var parsedOutput, _a, response, errorCode, _b, _c, _d, parsedBody, message;
4219
- var _e;
4220
- return __generator(this, function (_f) {
4221
- switch (_f.label) {
3815
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3816
+ var _c;
3817
+ return __generator(this, function (_d) {
3818
+ switch (_d.label) {
4222
3819
  case 0:
4223
3820
  _a = [__assign({}, output)];
4224
- _e = {};
3821
+ _c = {};
4225
3822
  return [4, parseBody(output.body, context)];
4226
3823
  case 1:
4227
- parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
3824
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
4228
3825
  errorCode = "UnknownError";
4229
3826
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
4230
3827
  _b = errorCode;
@@ -4235,28 +3832,18 @@ var deserializeAws_queryUpdateStackCommandError = function (output, context) { r
4235
3832
  case "com.amazonaws.cloudformation#TokenAlreadyExistsException": return [3, 4];
4236
3833
  }
4237
3834
  return [3, 6];
4238
- case 2:
4239
- _c = [{}];
4240
- return [4, deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)];
4241
- case 3:
4242
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4243
- return [3, 7];
4244
- case 4:
4245
- _d = [{}];
4246
- return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
4247
- case 5:
4248
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4249
- return [3, 7];
3835
+ case 2: return [4, deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)];
3836
+ case 3: throw _d.sent();
3837
+ case 4: return [4, deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)];
3838
+ case 5: throw _d.sent();
4250
3839
  case 6:
4251
3840
  parsedBody = parsedOutput.body;
4252
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
4253
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
4254
- _f.label = 7;
4255
- case 7:
4256
- message = response.message || response.Message || errorCode;
4257
- response.message = message;
4258
- delete response.Message;
4259
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3841
+ response = new __BaseException({
3842
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3843
+ $fault: "client",
3844
+ $metadata: deserializeMetadata(output),
3845
+ });
3846
+ throw __decorateServiceException(response, parsedBody.Error);
4260
3847
  }
4261
3848
  });
4262
3849
  }); };
@@ -4279,16 +3866,16 @@ export var deserializeAws_queryUpdateStackInstancesCommand = function (output, c
4279
3866
  });
4280
3867
  }); };
4281
3868
  var deserializeAws_queryUpdateStackInstancesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
4282
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, _h, parsedBody, message;
4283
- var _j;
4284
- return __generator(this, function (_k) {
4285
- switch (_k.label) {
3869
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3870
+ var _c;
3871
+ return __generator(this, function (_d) {
3872
+ switch (_d.label) {
4286
3873
  case 0:
4287
3874
  _a = [__assign({}, output)];
4288
- _j = {};
3875
+ _c = {};
4289
3876
  return [4, parseBody(output.body, context)];
4290
3877
  case 1:
4291
- parsedOutput = __assign.apply(void 0, _a.concat([(_j.body = _k.sent(), _j)]));
3878
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
4292
3879
  errorCode = "UnknownError";
4293
3880
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
4294
3881
  _b = errorCode;
@@ -4307,52 +3894,26 @@ var deserializeAws_queryUpdateStackInstancesCommandError = function (output, con
4307
3894
  case "com.amazonaws.cloudformation#StaleRequestException": return [3, 12];
4308
3895
  }
4309
3896
  return [3, 14];
4310
- case 2:
4311
- _c = [{}];
4312
- return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
4313
- case 3:
4314
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4315
- return [3, 15];
4316
- case 4:
4317
- _d = [{}];
4318
- return [4, deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)];
4319
- case 5:
4320
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4321
- return [3, 15];
4322
- case 6:
4323
- _e = [{}];
4324
- return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
4325
- case 7:
4326
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4327
- return [3, 15];
4328
- case 8:
4329
- _f = [{}];
4330
- return [4, deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context)];
4331
- case 9:
4332
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4333
- return [3, 15];
4334
- case 10:
4335
- _g = [{}];
4336
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
4337
- case 11:
4338
- response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4339
- return [3, 15];
4340
- case 12:
4341
- _h = [{}];
4342
- return [4, deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)];
4343
- case 13:
4344
- response = __assign.apply(void 0, [__assign.apply(void 0, _h.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4345
- return [3, 15];
3897
+ case 2: return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
3898
+ case 3: throw _d.sent();
3899
+ case 4: return [4, deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)];
3900
+ case 5: throw _d.sent();
3901
+ case 6: return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
3902
+ case 7: throw _d.sent();
3903
+ case 8: return [4, deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context)];
3904
+ case 9: throw _d.sent();
3905
+ case 10: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
3906
+ case 11: throw _d.sent();
3907
+ case 12: return [4, deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)];
3908
+ case 13: throw _d.sent();
4346
3909
  case 14:
4347
3910
  parsedBody = parsedOutput.body;
4348
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
4349
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
4350
- _k.label = 15;
4351
- case 15:
4352
- message = response.message || response.Message || errorCode;
4353
- response.message = message;
4354
- delete response.Message;
4355
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3911
+ response = new __BaseException({
3912
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3913
+ $fault: "client",
3914
+ $metadata: deserializeMetadata(output),
3915
+ });
3916
+ throw __decorateServiceException(response, parsedBody.Error);
4356
3917
  }
4357
3918
  });
4358
3919
  }); };
@@ -4375,16 +3936,16 @@ export var deserializeAws_queryUpdateStackSetCommand = function (output, context
4375
3936
  });
4376
3937
  }); };
4377
3938
  var deserializeAws_queryUpdateStackSetCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
4378
- var parsedOutput, _a, response, errorCode, _b, _c, _d, _e, _f, _g, _h, parsedBody, message;
4379
- var _j;
4380
- return __generator(this, function (_k) {
4381
- switch (_k.label) {
3939
+ var parsedOutput, _a, response, errorCode, _b, parsedBody;
3940
+ var _c;
3941
+ return __generator(this, function (_d) {
3942
+ switch (_d.label) {
4382
3943
  case 0:
4383
3944
  _a = [__assign({}, output)];
4384
- _j = {};
3945
+ _c = {};
4385
3946
  return [4, parseBody(output.body, context)];
4386
3947
  case 1:
4387
- parsedOutput = __assign.apply(void 0, _a.concat([(_j.body = _k.sent(), _j)]));
3948
+ parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
4388
3949
  errorCode = "UnknownError";
4389
3950
  errorCode = loadQueryErrorCode(output, parsedOutput.body);
4390
3951
  _b = errorCode;
@@ -4403,52 +3964,26 @@ var deserializeAws_queryUpdateStackSetCommandError = function (output, context)
4403
3964
  case "com.amazonaws.cloudformation#StaleRequestException": return [3, 12];
4404
3965
  }
4405
3966
  return [3, 14];
4406
- case 2:
4407
- _c = [{}];
4408
- return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
4409
- case 3:
4410
- response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4411
- return [3, 15];
4412
- case 4:
4413
- _d = [{}];
4414
- return [4, deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)];
4415
- case 5:
4416
- response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4417
- return [3, 15];
4418
- case 6:
4419
- _e = [{}];
4420
- return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
4421
- case 7:
4422
- response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4423
- return [3, 15];
4424
- case 8:
4425
- _f = [{}];
4426
- return [4, deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context)];
4427
- case 9:
4428
- response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4429
- return [3, 15];
4430
- case 10:
4431
- _g = [{}];
4432
- return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
4433
- case 11:
4434
- response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4435
- return [3, 15];
4436
- case 12:
4437
- _h = [{}];
4438
- return [4, deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)];
4439
- case 13:
4440
- response = __assign.apply(void 0, [__assign.apply(void 0, _h.concat([(_k.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
4441
- return [3, 15];
3967
+ case 2: return [4, deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)];
3968
+ case 3: throw _d.sent();
3969
+ case 4: return [4, deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)];
3970
+ case 5: throw _d.sent();
3971
+ case 6: return [4, deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)];
3972
+ case 7: throw _d.sent();
3973
+ case 8: return [4, deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context)];
3974
+ case 9: throw _d.sent();
3975
+ case 10: return [4, deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)];
3976
+ case 11: throw _d.sent();
3977
+ case 12: return [4, deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)];
3978
+ case 13: throw _d.sent();
4442
3979
  case 14:
4443
3980
  parsedBody = parsedOutput.body;
4444
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
4445
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
4446
- _k.label = 15;
4447
- case 15:
4448
- message = response.message || response.Message || errorCode;
4449
- response.message = message;
4450
- delete response.Message;
4451
- return [2, Promise.reject(Object.assign(new Error(message), response))];
3981
+ response = new __BaseException({
3982
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
3983
+ $fault: "client",
3984
+ $metadata: deserializeMetadata(output),
3985
+ });
3986
+ throw __decorateServiceException(response, parsedBody.Error);
4452
3987
  }
4453
3988
  });
4454
3989
  }); };
@@ -4471,7 +4006,7 @@ export var deserializeAws_queryUpdateTerminationProtectionCommand = function (ou
4471
4006
  });
4472
4007
  }); };
4473
4008
  var deserializeAws_queryUpdateTerminationProtectionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
4474
- var parsedOutput, _a, response, errorCode, parsedBody, message;
4009
+ var parsedOutput, _a, response, errorCode, parsedBody;
4475
4010
  var _b;
4476
4011
  return __generator(this, function (_c) {
4477
4012
  switch (_c.label) {
@@ -4486,13 +4021,14 @@ var deserializeAws_queryUpdateTerminationProtectionCommandError = function (outp
4486
4021
  switch (errorCode) {
4487
4022
  default:
4488
4023
  parsedBody = parsedOutput.body;
4489
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
4490
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
4024
+ response = new __BaseException({
4025
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
4026
+ $fault: "client",
4027
+ $metadata: deserializeMetadata(output),
4028
+ });
4029
+ throw __decorateServiceException(response, parsedBody.Error);
4491
4030
  }
4492
- message = response.message || response.Message || errorCode;
4493
- response.message = message;
4494
- delete response.Message;
4495
- return [2, Promise.reject(Object.assign(new Error(message), response))];
4031
+ return [2];
4496
4032
  }
4497
4033
  });
4498
4034
  }); };
@@ -4515,7 +4051,7 @@ export var deserializeAws_queryValidateTemplateCommand = function (output, conte
4515
4051
  });
4516
4052
  }); };
4517
4053
  var deserializeAws_queryValidateTemplateCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
4518
- var parsedOutput, _a, response, errorCode, parsedBody, message;
4054
+ var parsedOutput, _a, response, errorCode, parsedBody;
4519
4055
  var _b;
4520
4056
  return __generator(this, function (_c) {
4521
4057
  switch (_c.label) {
@@ -4530,212 +4066,213 @@ var deserializeAws_queryValidateTemplateCommandError = function (output, context
4530
4066
  switch (errorCode) {
4531
4067
  default:
4532
4068
  parsedBody = parsedOutput.body;
4533
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
4534
- response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
4069
+ response = new __BaseException({
4070
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
4071
+ $fault: "client",
4072
+ $metadata: deserializeMetadata(output),
4073
+ });
4074
+ throw __decorateServiceException(response, parsedBody.Error);
4535
4075
  }
4536
- message = response.message || response.Message || errorCode;
4537
- response.message = message;
4538
- delete response.Message;
4539
- return [2, Promise.reject(Object.assign(new Error(message), response))];
4076
+ return [2];
4540
4077
  }
4541
4078
  });
4542
4079
  }); };
4543
4080
  var deserializeAws_queryAlreadyExistsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4544
- var body, deserialized, contents;
4081
+ var body, deserialized, exception;
4545
4082
  return __generator(this, function (_a) {
4546
4083
  body = parsedOutput.body;
4547
4084
  deserialized = deserializeAws_queryAlreadyExistsException(body.Error, context);
4548
- contents = __assign({ name: "AlreadyExistsException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4549
- return [2, contents];
4085
+ exception = new AlreadyExistsException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4086
+ return [2, __decorateServiceException(exception, body)];
4550
4087
  });
4551
4088
  }); };
4552
4089
  var deserializeAws_queryCFNRegistryExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4553
- var body, deserialized, contents;
4090
+ var body, deserialized, exception;
4554
4091
  return __generator(this, function (_a) {
4555
4092
  body = parsedOutput.body;
4556
4093
  deserialized = deserializeAws_queryCFNRegistryException(body.Error, context);
4557
- contents = __assign({ name: "CFNRegistryException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4558
- return [2, contents];
4094
+ exception = new CFNRegistryException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4095
+ return [2, __decorateServiceException(exception, body)];
4559
4096
  });
4560
4097
  }); };
4561
4098
  var deserializeAws_queryChangeSetNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4562
- var body, deserialized, contents;
4099
+ var body, deserialized, exception;
4563
4100
  return __generator(this, function (_a) {
4564
4101
  body = parsedOutput.body;
4565
4102
  deserialized = deserializeAws_queryChangeSetNotFoundException(body.Error, context);
4566
- contents = __assign({ name: "ChangeSetNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4567
- return [2, contents];
4103
+ exception = new ChangeSetNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4104
+ return [2, __decorateServiceException(exception, body)];
4568
4105
  });
4569
4106
  }); };
4570
4107
  var deserializeAws_queryCreatedButModifiedExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4571
- var body, deserialized, contents;
4108
+ var body, deserialized, exception;
4572
4109
  return __generator(this, function (_a) {
4573
4110
  body = parsedOutput.body;
4574
4111
  deserialized = deserializeAws_queryCreatedButModifiedException(body.Error, context);
4575
- contents = __assign({ name: "CreatedButModifiedException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4576
- return [2, contents];
4112
+ exception = new CreatedButModifiedException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4113
+ return [2, __decorateServiceException(exception, body)];
4577
4114
  });
4578
4115
  }); };
4579
4116
  var deserializeAws_queryInsufficientCapabilitiesExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4580
- var body, deserialized, contents;
4117
+ var body, deserialized, exception;
4581
4118
  return __generator(this, function (_a) {
4582
4119
  body = parsedOutput.body;
4583
4120
  deserialized = deserializeAws_queryInsufficientCapabilitiesException(body.Error, context);
4584
- contents = __assign({ name: "InsufficientCapabilitiesException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4585
- return [2, contents];
4121
+ exception = new InsufficientCapabilitiesException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4122
+ return [2, __decorateServiceException(exception, body)];
4586
4123
  });
4587
4124
  }); };
4588
4125
  var deserializeAws_queryInvalidChangeSetStatusExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4589
- var body, deserialized, contents;
4126
+ var body, deserialized, exception;
4590
4127
  return __generator(this, function (_a) {
4591
4128
  body = parsedOutput.body;
4592
4129
  deserialized = deserializeAws_queryInvalidChangeSetStatusException(body.Error, context);
4593
- contents = __assign({ name: "InvalidChangeSetStatusException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4594
- return [2, contents];
4130
+ exception = new InvalidChangeSetStatusException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4131
+ return [2, __decorateServiceException(exception, body)];
4595
4132
  });
4596
4133
  }); };
4597
4134
  var deserializeAws_queryInvalidOperationExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4598
- var body, deserialized, contents;
4135
+ var body, deserialized, exception;
4599
4136
  return __generator(this, function (_a) {
4600
4137
  body = parsedOutput.body;
4601
4138
  deserialized = deserializeAws_queryInvalidOperationException(body.Error, context);
4602
- contents = __assign({ name: "InvalidOperationException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4603
- return [2, contents];
4139
+ exception = new InvalidOperationException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4140
+ return [2, __decorateServiceException(exception, body)];
4604
4141
  });
4605
4142
  }); };
4606
4143
  var deserializeAws_queryInvalidStateTransitionExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4607
- var body, deserialized, contents;
4144
+ var body, deserialized, exception;
4608
4145
  return __generator(this, function (_a) {
4609
4146
  body = parsedOutput.body;
4610
4147
  deserialized = deserializeAws_queryInvalidStateTransitionException(body.Error, context);
4611
- contents = __assign({ name: "InvalidStateTransitionException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4612
- return [2, contents];
4148
+ exception = new InvalidStateTransitionException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4149
+ return [2, __decorateServiceException(exception, body)];
4613
4150
  });
4614
4151
  }); };
4615
4152
  var deserializeAws_queryLimitExceededExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4616
- var body, deserialized, contents;
4153
+ var body, deserialized, exception;
4617
4154
  return __generator(this, function (_a) {
4618
4155
  body = parsedOutput.body;
4619
4156
  deserialized = deserializeAws_queryLimitExceededException(body.Error, context);
4620
- contents = __assign({ name: "LimitExceededException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4621
- return [2, contents];
4157
+ exception = new LimitExceededException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4158
+ return [2, __decorateServiceException(exception, body)];
4622
4159
  });
4623
4160
  }); };
4624
4161
  var deserializeAws_queryNameAlreadyExistsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4625
- var body, deserialized, contents;
4162
+ var body, deserialized, exception;
4626
4163
  return __generator(this, function (_a) {
4627
4164
  body = parsedOutput.body;
4628
4165
  deserialized = deserializeAws_queryNameAlreadyExistsException(body.Error, context);
4629
- contents = __assign({ name: "NameAlreadyExistsException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4630
- return [2, contents];
4166
+ exception = new NameAlreadyExistsException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4167
+ return [2, __decorateServiceException(exception, body)];
4631
4168
  });
4632
4169
  }); };
4633
4170
  var deserializeAws_queryOperationIdAlreadyExistsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4634
- var body, deserialized, contents;
4171
+ var body, deserialized, exception;
4635
4172
  return __generator(this, function (_a) {
4636
4173
  body = parsedOutput.body;
4637
4174
  deserialized = deserializeAws_queryOperationIdAlreadyExistsException(body.Error, context);
4638
- contents = __assign({ name: "OperationIdAlreadyExistsException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4639
- return [2, contents];
4175
+ exception = new OperationIdAlreadyExistsException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4176
+ return [2, __decorateServiceException(exception, body)];
4640
4177
  });
4641
4178
  }); };
4642
4179
  var deserializeAws_queryOperationInProgressExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4643
- var body, deserialized, contents;
4180
+ var body, deserialized, exception;
4644
4181
  return __generator(this, function (_a) {
4645
4182
  body = parsedOutput.body;
4646
4183
  deserialized = deserializeAws_queryOperationInProgressException(body.Error, context);
4647
- contents = __assign({ name: "OperationInProgressException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4648
- return [2, contents];
4184
+ exception = new OperationInProgressException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4185
+ return [2, __decorateServiceException(exception, body)];
4649
4186
  });
4650
4187
  }); };
4651
4188
  var deserializeAws_queryOperationNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4652
- var body, deserialized, contents;
4189
+ var body, deserialized, exception;
4653
4190
  return __generator(this, function (_a) {
4654
4191
  body = parsedOutput.body;
4655
4192
  deserialized = deserializeAws_queryOperationNotFoundException(body.Error, context);
4656
- contents = __assign({ name: "OperationNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4657
- return [2, contents];
4193
+ exception = new OperationNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4194
+ return [2, __decorateServiceException(exception, body)];
4658
4195
  });
4659
4196
  }); };
4660
4197
  var deserializeAws_queryOperationStatusCheckFailedExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4661
- var body, deserialized, contents;
4198
+ var body, deserialized, exception;
4662
4199
  return __generator(this, function (_a) {
4663
4200
  body = parsedOutput.body;
4664
4201
  deserialized = deserializeAws_queryOperationStatusCheckFailedException(body.Error, context);
4665
- contents = __assign({ name: "OperationStatusCheckFailedException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4666
- return [2, contents];
4202
+ exception = new OperationStatusCheckFailedException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4203
+ return [2, __decorateServiceException(exception, body)];
4667
4204
  });
4668
4205
  }); };
4669
4206
  var deserializeAws_queryStackInstanceNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4670
- var body, deserialized, contents;
4207
+ var body, deserialized, exception;
4671
4208
  return __generator(this, function (_a) {
4672
4209
  body = parsedOutput.body;
4673
4210
  deserialized = deserializeAws_queryStackInstanceNotFoundException(body.Error, context);
4674
- contents = __assign({ name: "StackInstanceNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4675
- return [2, contents];
4211
+ exception = new StackInstanceNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4212
+ return [2, __decorateServiceException(exception, body)];
4676
4213
  });
4677
4214
  }); };
4678
4215
  var deserializeAws_queryStackNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4679
- var body, deserialized, contents;
4216
+ var body, deserialized, exception;
4680
4217
  return __generator(this, function (_a) {
4681
4218
  body = parsedOutput.body;
4682
4219
  deserialized = deserializeAws_queryStackNotFoundException(body.Error, context);
4683
- contents = __assign({ name: "StackNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4684
- return [2, contents];
4220
+ exception = new StackNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4221
+ return [2, __decorateServiceException(exception, body)];
4685
4222
  });
4686
4223
  }); };
4687
4224
  var deserializeAws_queryStackSetNotEmptyExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4688
- var body, deserialized, contents;
4225
+ var body, deserialized, exception;
4689
4226
  return __generator(this, function (_a) {
4690
4227
  body = parsedOutput.body;
4691
4228
  deserialized = deserializeAws_queryStackSetNotEmptyException(body.Error, context);
4692
- contents = __assign({ name: "StackSetNotEmptyException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4693
- return [2, contents];
4229
+ exception = new StackSetNotEmptyException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4230
+ return [2, __decorateServiceException(exception, body)];
4694
4231
  });
4695
4232
  }); };
4696
4233
  var deserializeAws_queryStackSetNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4697
- var body, deserialized, contents;
4234
+ var body, deserialized, exception;
4698
4235
  return __generator(this, function (_a) {
4699
4236
  body = parsedOutput.body;
4700
4237
  deserialized = deserializeAws_queryStackSetNotFoundException(body.Error, context);
4701
- contents = __assign({ name: "StackSetNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4702
- return [2, contents];
4238
+ exception = new StackSetNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4239
+ return [2, __decorateServiceException(exception, body)];
4703
4240
  });
4704
4241
  }); };
4705
4242
  var deserializeAws_queryStaleRequestExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4706
- var body, deserialized, contents;
4243
+ var body, deserialized, exception;
4707
4244
  return __generator(this, function (_a) {
4708
4245
  body = parsedOutput.body;
4709
4246
  deserialized = deserializeAws_queryStaleRequestException(body.Error, context);
4710
- contents = __assign({ name: "StaleRequestException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4711
- return [2, contents];
4247
+ exception = new StaleRequestException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4248
+ return [2, __decorateServiceException(exception, body)];
4712
4249
  });
4713
4250
  }); };
4714
4251
  var deserializeAws_queryTokenAlreadyExistsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4715
- var body, deserialized, contents;
4252
+ var body, deserialized, exception;
4716
4253
  return __generator(this, function (_a) {
4717
4254
  body = parsedOutput.body;
4718
4255
  deserialized = deserializeAws_queryTokenAlreadyExistsException(body.Error, context);
4719
- contents = __assign({ name: "TokenAlreadyExistsException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4720
- return [2, contents];
4256
+ exception = new TokenAlreadyExistsException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4257
+ return [2, __decorateServiceException(exception, body)];
4721
4258
  });
4722
4259
  }); };
4723
4260
  var deserializeAws_queryTypeConfigurationNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4724
- var body, deserialized, contents;
4261
+ var body, deserialized, exception;
4725
4262
  return __generator(this, function (_a) {
4726
4263
  body = parsedOutput.body;
4727
4264
  deserialized = deserializeAws_queryTypeConfigurationNotFoundException(body.Error, context);
4728
- contents = __assign({ name: "TypeConfigurationNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4729
- return [2, contents];
4265
+ exception = new TypeConfigurationNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4266
+ return [2, __decorateServiceException(exception, body)];
4730
4267
  });
4731
4268
  }); };
4732
4269
  var deserializeAws_queryTypeNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
4733
- var body, deserialized, contents;
4270
+ var body, deserialized, exception;
4734
4271
  return __generator(this, function (_a) {
4735
4272
  body = parsedOutput.body;
4736
4273
  deserialized = deserializeAws_queryTypeNotFoundException(body.Error, context);
4737
- contents = __assign({ name: "TypeNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
4738
- return [2, contents];
4274
+ exception = new TypeNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
4275
+ return [2, __decorateServiceException(exception, body)];
4739
4276
  });
4740
4277
  }); };
4741
4278
  var serializeAws_queryAccountList = function (input, context) {