@aws-sdk/client-sts 3.186.0 → 3.188.0

package/dist-es/protocols/Aws_query.js

@@ -1,616 +1,478 @@
-import { __assign, __awaiter, __generator, __read, __values } from "tslib";
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectString as __expectString, extendedEncodeURIComponent as __extendedEncodeURIComponent, getValueFromTextNode as __getValueFromTextNode, parseRfc3339DateTime as __parseRfc3339DateTime, strictParseInt32 as __strictParseInt32, throwDefaultError, } from "@aws-sdk/smithy-client";
-import { decodeHTML } from "entities";
-import { parse as xmlParse } from "fast-xml-parser";
+import { XMLParser } from "fast-xml-parser";
 import { ExpiredTokenException, IDPCommunicationErrorException, IDPRejectedClaimException, InvalidAuthorizationMessageException, InvalidIdentityTokenException, MalformedPolicyDocumentException, PackedPolicyTooLargeException, RegionDisabledException, } from "../models/models_0";
 import { STSServiceException as __BaseException } from "../models/STSServiceException";
-export var serializeAws_queryAssumeRoleCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var headers, body;
-    return __generator(this, function (_a) {
-        headers = {
-            "content-type": "application/x-www-form-urlencoded",
-        };
-        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryAssumeRoleRequest(input, context)), { Action: "AssumeRole", Version: "2011-06-15" }));
-        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
-    });
-}); };
-export var serializeAws_queryAssumeRoleWithSAMLCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var headers, body;
-    return __generator(this, function (_a) {
-        headers = {
-            "content-type": "application/x-www-form-urlencoded",
-        };
-        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryAssumeRoleWithSAMLRequest(input, context)), { Action: "AssumeRoleWithSAML", Version: "2011-06-15" }));
-        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
-    });
-}); };
-export var serializeAws_queryAssumeRoleWithWebIdentityCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var headers, body;
-    return __generator(this, function (_a) {
-        headers = {
-            "content-type": "application/x-www-form-urlencoded",
-        };
-        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryAssumeRoleWithWebIdentityRequest(input, context)), { Action: "AssumeRoleWithWebIdentity", Version: "2011-06-15" }));
-        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
-    });
-}); };
-export var serializeAws_queryDecodeAuthorizationMessageCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var headers, body;
-    return __generator(this, function (_a) {
-        headers = {
-            "content-type": "application/x-www-form-urlencoded",
-        };
-        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDecodeAuthorizationMessageRequest(input, context)), { Action: "DecodeAuthorizationMessage", Version: "2011-06-15" }));
-        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
-    });
-}); };
-export var serializeAws_queryGetAccessKeyInfoCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var headers, body;
-    return __generator(this, function (_a) {
-        headers = {
-            "content-type": "application/x-www-form-urlencoded",
-        };
-        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryGetAccessKeyInfoRequest(input, context)), { Action: "GetAccessKeyInfo", Version: "2011-06-15" }));
-        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
-    });
-}); };
-export var serializeAws_queryGetCallerIdentityCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var headers, body;
-    return __generator(this, function (_a) {
-        headers = {
-            "content-type": "application/x-www-form-urlencoded",
-        };
-        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryGetCallerIdentityRequest(input, context)), { Action: "GetCallerIdentity", Version: "2011-06-15" }));
-        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
-    });
-}); };
-export var serializeAws_queryGetFederationTokenCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var headers, body;
-    return __generator(this, function (_a) {
-        headers = {
-            "content-type": "application/x-www-form-urlencoded",
-        };
-        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryGetFederationTokenRequest(input, context)), { Action: "GetFederationToken", Version: "2011-06-15" }));
-        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
-    });
-}); };
-export var serializeAws_queryGetSessionTokenCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var headers, body;
-    return __generator(this, function (_a) {
-        headers = {
-            "content-type": "application/x-www-form-urlencoded",
-        };
-        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryGetSessionTokenRequest(input, context)), { Action: "GetSessionToken", Version: "2011-06-15" }));
-        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
-    });
-}); };
-export var deserializeAws_queryAssumeRoleCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var data, contents, response;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (output.statusCode >= 300) {
-                    return [2, deserializeAws_queryAssumeRoleCommandError(output, context)];
-                }
-                return [4, parseBody(output.body, context)];
-            case 1:
-                data = _a.sent();
-                contents = {};
-                contents = deserializeAws_queryAssumeRoleResponse(data.AssumeRoleResult, context);
-                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2, Promise.resolve(response)];
-        }
-    });
-}); };
-var deserializeAws_queryAssumeRoleCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var parsedOutput, _a, errorCode, _b, parsedBody;
-    var _c;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
-            case 0:
-                _a = [__assign({}, output)];
-                _c = {};
-                return [4, parseErrorBody(output.body, context)];
-            case 1:
-                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
-                errorCode = loadQueryErrorCode(output, parsedOutput.body);
-                _b = errorCode;
-                switch (_b) {
-                    case "ExpiredTokenException": return [3, 2];
-                    case "com.amazonaws.sts#ExpiredTokenException": return [3, 2];
-                    case "MalformedPolicyDocument": return [3, 4];
-                    case "com.amazonaws.sts#MalformedPolicyDocumentException": return [3, 4];
-                    case "PackedPolicyTooLarge": return [3, 6];
-                    case "com.amazonaws.sts#PackedPolicyTooLargeException": return [3, 6];
-                    case "RegionDisabledException": return [3, 8];
-                    case "com.amazonaws.sts#RegionDisabledException": return [3, 8];
-                }
-                return [3, 10];
-            case 2: return [4, deserializeAws_queryExpiredTokenExceptionResponse(parsedOutput, context)];
-            case 3: throw _d.sent();
-            case 4: return [4, deserializeAws_queryMalformedPolicyDocumentExceptionResponse(parsedOutput, context)];
-            case 5: throw _d.sent();
-            case 6: return [4, deserializeAws_queryPackedPolicyTooLargeExceptionResponse(parsedOutput, context)];
-            case 7: throw _d.sent();
-            case 8: return [4, deserializeAws_queryRegionDisabledExceptionResponse(parsedOutput, context)];
-            case 9: throw _d.sent();
-            case 10:
-                parsedBody = parsedOutput.body;
-                throwDefaultError({
-                    output: output,
-                    parsedBody: parsedBody.Error,
-                    exceptionCtor: __BaseException,
-                    errorCode: errorCode,
-                });
-                _d.label = 11;
-            case 11: return [2];
-        }
-    });
-}); };
-export var deserializeAws_queryAssumeRoleWithSAMLCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var data, contents, response;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (output.statusCode >= 300) {
-                    return [2, deserializeAws_queryAssumeRoleWithSAMLCommandError(output, context)];
-                }
-                return [4, parseBody(output.body, context)];
-            case 1:
-                data = _a.sent();
-                contents = {};
-                contents = deserializeAws_queryAssumeRoleWithSAMLResponse(data.AssumeRoleWithSAMLResult, context);
-                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2, Promise.resolve(response)];
-        }
-    });
-}); };
-var deserializeAws_queryAssumeRoleWithSAMLCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var parsedOutput, _a, errorCode, _b, parsedBody;
-    var _c;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
-            case 0:
-                _a = [__assign({}, output)];
-                _c = {};
-                return [4, parseErrorBody(output.body, context)];
-            case 1:
-                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
-                errorCode = loadQueryErrorCode(output, parsedOutput.body);
-                _b = errorCode;
-                switch (_b) {
-                    case "ExpiredTokenException": return [3, 2];
-                    case "com.amazonaws.sts#ExpiredTokenException": return [3, 2];
-                    case "IDPRejectedClaim": return [3, 4];
-                    case "com.amazonaws.sts#IDPRejectedClaimException": return [3, 4];
-                    case "InvalidIdentityToken": return [3, 6];
-                    case "com.amazonaws.sts#InvalidIdentityTokenException": return [3, 6];
-                    case "MalformedPolicyDocument": return [3, 8];
-                    case "com.amazonaws.sts#MalformedPolicyDocumentException": return [3, 8];
-                    case "PackedPolicyTooLarge": return [3, 10];
-                    case "com.amazonaws.sts#PackedPolicyTooLargeException": return [3, 10];
-                    case "RegionDisabledException": return [3, 12];
-                    case "com.amazonaws.sts#RegionDisabledException": return [3, 12];
-                }
-                return [3, 14];
-            case 2: return [4, deserializeAws_queryExpiredTokenExceptionResponse(parsedOutput, context)];
-            case 3: throw _d.sent();
-            case 4: return [4, deserializeAws_queryIDPRejectedClaimExceptionResponse(parsedOutput, context)];
-            case 5: throw _d.sent();
-            case 6: return [4, deserializeAws_queryInvalidIdentityTokenExceptionResponse(parsedOutput, context)];
-            case 7: throw _d.sent();
-            case 8: return [4, deserializeAws_queryMalformedPolicyDocumentExceptionResponse(parsedOutput, context)];
-            case 9: throw _d.sent();
-            case 10: return [4, deserializeAws_queryPackedPolicyTooLargeExceptionResponse(parsedOutput, context)];
-            case 11: throw _d.sent();
-            case 12: return [4, deserializeAws_queryRegionDisabledExceptionResponse(parsedOutput, context)];
-            case 13: throw _d.sent();
-            case 14:
-                parsedBody = parsedOutput.body;
-                throwDefaultError({
-                    output: output,
-                    parsedBody: parsedBody.Error,
-                    exceptionCtor: __BaseException,
-                    errorCode: errorCode,
-                });
-                _d.label = 15;
-            case 15: return [2];
-        }
-    });
-}); };
-export var deserializeAws_queryAssumeRoleWithWebIdentityCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var data, contents, response;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (output.statusCode >= 300) {
-                    return [2, deserializeAws_queryAssumeRoleWithWebIdentityCommandError(output, context)];
-                }
-                return [4, parseBody(output.body, context)];
-            case 1:
-                data = _a.sent();
-                contents = {};
-                contents = deserializeAws_queryAssumeRoleWithWebIdentityResponse(data.AssumeRoleWithWebIdentityResult, context);
-                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2, Promise.resolve(response)];
-        }
-    });
-}); };
-var deserializeAws_queryAssumeRoleWithWebIdentityCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var parsedOutput, _a, errorCode, _b, parsedBody;
-    var _c;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
-            case 0:
-                _a = [__assign({}, output)];
-                _c = {};
-                return [4, parseErrorBody(output.body, context)];
-            case 1:
-                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
-                errorCode = loadQueryErrorCode(output, parsedOutput.body);
-                _b = errorCode;
-                switch (_b) {
-                    case "ExpiredTokenException": return [3, 2];
-                    case "com.amazonaws.sts#ExpiredTokenException": return [3, 2];
-                    case "IDPCommunicationError": return [3, 4];
-                    case "com.amazonaws.sts#IDPCommunicationErrorException": return [3, 4];
-                    case "IDPRejectedClaim": return [3, 6];
-                    case "com.amazonaws.sts#IDPRejectedClaimException": return [3, 6];
-                    case "InvalidIdentityToken": return [3, 8];
-                    case "com.amazonaws.sts#InvalidIdentityTokenException": return [3, 8];
-                    case "MalformedPolicyDocument": return [3, 10];
-                    case "com.amazonaws.sts#MalformedPolicyDocumentException": return [3, 10];
-                    case "PackedPolicyTooLarge": return [3, 12];
-                    case "com.amazonaws.sts#PackedPolicyTooLargeException": return [3, 12];
-                    case "RegionDisabledException": return [3, 14];
-                    case "com.amazonaws.sts#RegionDisabledException": return [3, 14];
-                }
-                return [3, 16];
-            case 2: return [4, deserializeAws_queryExpiredTokenExceptionResponse(parsedOutput, context)];
-            case 3: throw _d.sent();
-            case 4: return [4, deserializeAws_queryIDPCommunicationErrorExceptionResponse(parsedOutput, context)];
-            case 5: throw _d.sent();
-            case 6: return [4, deserializeAws_queryIDPRejectedClaimExceptionResponse(parsedOutput, context)];
-            case 7: throw _d.sent();
-            case 8: return [4, deserializeAws_queryInvalidIdentityTokenExceptionResponse(parsedOutput, context)];
-            case 9: throw _d.sent();
-            case 10: return [4, deserializeAws_queryMalformedPolicyDocumentExceptionResponse(parsedOutput, context)];
-            case 11: throw _d.sent();
-            case 12: return [4, deserializeAws_queryPackedPolicyTooLargeExceptionResponse(parsedOutput, context)];
-            case 13: throw _d.sent();
-            case 14: return [4, deserializeAws_queryRegionDisabledExceptionResponse(parsedOutput, context)];
-            case 15: throw _d.sent();
-            case 16:
-                parsedBody = parsedOutput.body;
-                throwDefaultError({
-                    output: output,
-                    parsedBody: parsedBody.Error,
-                    exceptionCtor: __BaseException,
-                    errorCode: errorCode,
-                });
-                _d.label = 17;
-            case 17: return [2];
-        }
-    });
-}); };
-export var deserializeAws_queryDecodeAuthorizationMessageCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var data, contents, response;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (output.statusCode >= 300) {
-                    return [2, deserializeAws_queryDecodeAuthorizationMessageCommandError(output, context)];
-                }
-                return [4, parseBody(output.body, context)];
-            case 1:
-                data = _a.sent();
-                contents = {};
-                contents = deserializeAws_queryDecodeAuthorizationMessageResponse(data.DecodeAuthorizationMessageResult, context);
-                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2, Promise.resolve(response)];
-        }
+export const serializeAws_queryAssumeRoleCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryAssumeRoleRequest(input, context),
+        Action: "AssumeRole",
+        Version: "2011-06-15",
     });
-}); };
-var deserializeAws_queryDecodeAuthorizationMessageCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var parsedOutput, _a, errorCode, _b, parsedBody;
-    var _c;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
-            case 0:
-                _a = [__assign({}, output)];
-                _c = {};
-                return [4, parseErrorBody(output.body, context)];
-            case 1:
-                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
-                errorCode = loadQueryErrorCode(output, parsedOutput.body);
-                _b = errorCode;
-                switch (_b) {
-                    case "InvalidAuthorizationMessageException": return [3, 2];
-                    case "com.amazonaws.sts#InvalidAuthorizationMessageException": return [3, 2];
-                }
-                return [3, 4];
-            case 2: return [4, deserializeAws_queryInvalidAuthorizationMessageExceptionResponse(parsedOutput, context)];
-            case 3: throw _d.sent();
-            case 4:
-                parsedBody = parsedOutput.body;
-                throwDefaultError({
-                    output: output,
-                    parsedBody: parsedBody.Error,
-                    exceptionCtor: __BaseException,
-                    errorCode: errorCode,
-                });
-                _d.label = 5;
-            case 5: return [2];
-        }
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_queryAssumeRoleWithSAMLCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryAssumeRoleWithSAMLRequest(input, context),
+        Action: "AssumeRoleWithSAML",
+        Version: "2011-06-15",
     });
-}); };
-export var deserializeAws_queryGetAccessKeyInfoCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var data, contents, response;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (output.statusCode >= 300) {
-                    return [2, deserializeAws_queryGetAccessKeyInfoCommandError(output, context)];
-                }
-                return [4, parseBody(output.body, context)];
-            case 1:
-                data = _a.sent();
-                contents = {};
-                contents = deserializeAws_queryGetAccessKeyInfoResponse(data.GetAccessKeyInfoResult, context);
-                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2, Promise.resolve(response)];
-        }
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_queryAssumeRoleWithWebIdentityCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryAssumeRoleWithWebIdentityRequest(input, context),
+        Action: "AssumeRoleWithWebIdentity",
+        Version: "2011-06-15",
     });
-}); };
-var deserializeAws_queryGetAccessKeyInfoCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var parsedOutput, _a, errorCode, parsedBody;
-    var _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                _a = [__assign({}, output)];
-                _b = {};
-                return [4, parseErrorBody(output.body, context)];
-            case 1:
-                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
-                errorCode = loadQueryErrorCode(output, parsedOutput.body);
-                parsedBody = parsedOutput.body;
-                throwDefaultError({
-                    output: output,
-                    parsedBody: parsedBody.Error,
-                    exceptionCtor: __BaseException,
-                    errorCode: errorCode,
-                });
-                return [2];
-        }
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_queryDecodeAuthorizationMessageCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryDecodeAuthorizationMessageRequest(input, context),
+        Action: "DecodeAuthorizationMessage",
+        Version: "2011-06-15",
     });
-}); };
-export var deserializeAws_queryGetCallerIdentityCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var data, contents, response;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (output.statusCode >= 300) {
-                    return [2, deserializeAws_queryGetCallerIdentityCommandError(output, context)];
-                }
-                return [4, parseBody(output.body, context)];
-            case 1:
-                data = _a.sent();
-                contents = {};
-                contents = deserializeAws_queryGetCallerIdentityResponse(data.GetCallerIdentityResult, context);
-                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2, Promise.resolve(response)];
-        }
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_queryGetAccessKeyInfoCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryGetAccessKeyInfoRequest(input, context),
+        Action: "GetAccessKeyInfo",
+        Version: "2011-06-15",
     });
-}); };
-var deserializeAws_queryGetCallerIdentityCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var parsedOutput, _a, errorCode, parsedBody;
-    var _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                _a = [__assign({}, output)];
-                _b = {};
-                return [4, parseErrorBody(output.body, context)];
-            case 1:
-                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
-                errorCode = loadQueryErrorCode(output, parsedOutput.body);
-                parsedBody = parsedOutput.body;
-                throwDefaultError({
-                    output: output,
-                    parsedBody: parsedBody.Error,
-                    exceptionCtor: __BaseException,
-                    errorCode: errorCode,
-                });
-                return [2];
-        }
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_queryGetCallerIdentityCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryGetCallerIdentityRequest(input, context),
+        Action: "GetCallerIdentity",
+        Version: "2011-06-15",
     });
-}); };
-export var deserializeAws_queryGetFederationTokenCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var data, contents, response;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (output.statusCode >= 300) {
-                    return [2, deserializeAws_queryGetFederationTokenCommandError(output, context)];
-                }
-                return [4, parseBody(output.body, context)];
-            case 1:
-                data = _a.sent();
-                contents = {};
-                contents = deserializeAws_queryGetFederationTokenResponse(data.GetFederationTokenResult, context);
-                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2, Promise.resolve(response)];
-        }
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_queryGetFederationTokenCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryGetFederationTokenRequest(input, context),
+        Action: "GetFederationToken",
+        Version: "2011-06-15",
     });
-}); };
-var deserializeAws_queryGetFederationTokenCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var parsedOutput, _a, errorCode, _b, parsedBody;
-    var _c;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
-            case 0:
-                _a = [__assign({}, output)];
-                _c = {};
-                return [4, parseErrorBody(output.body, context)];
-            case 1:
-                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
-                errorCode = loadQueryErrorCode(output, parsedOutput.body);
-                _b = errorCode;
-                switch (_b) {
-                    case "MalformedPolicyDocument": return [3, 2];
-                    case "com.amazonaws.sts#MalformedPolicyDocumentException": return [3, 2];
-                    case "PackedPolicyTooLarge": return [3, 4];
-                    case "com.amazonaws.sts#PackedPolicyTooLargeException": return [3, 4];
-                    case "RegionDisabledException": return [3, 6];
-                    case "com.amazonaws.sts#RegionDisabledException": return [3, 6];
-                }
-                return [3, 8];
-            case 2: return [4, deserializeAws_queryMalformedPolicyDocumentExceptionResponse(parsedOutput, context)];
-            case 3: throw _d.sent();
-            case 4: return [4, deserializeAws_queryPackedPolicyTooLargeExceptionResponse(parsedOutput, context)];
-            case 5: throw _d.sent();
-            case 6: return [4, deserializeAws_queryRegionDisabledExceptionResponse(parsedOutput, context)];
-            case 7: throw _d.sent();
-            case 8:
-                parsedBody = parsedOutput.body;
-                throwDefaultError({
-                    output: output,
-                    parsedBody: parsedBody.Error,
-                    exceptionCtor: __BaseException,
-                    errorCode: errorCode,
-                });
-                _d.label = 9;
-            case 9: return [2];
-        }
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_queryGetSessionTokenCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryGetSessionTokenRequest(input, context),
+        Action: "GetSessionToken",
+        Version: "2011-06-15",
     });
-}); };
-export var deserializeAws_queryGetSessionTokenCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var data, contents, response;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (output.statusCode >= 300) {
-                    return [2, deserializeAws_queryGetSessionTokenCommandError(output, context)];
-                }
-                return [4, parseBody(output.body, context)];
-            case 1:
-                data = _a.sent();
-                contents = {};
-                contents = deserializeAws_queryGetSessionTokenResponse(data.GetSessionTokenResult, context);
-                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2, Promise.resolve(response)];
-        }
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const deserializeAws_queryAssumeRoleCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryAssumeRoleCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryAssumeRoleResponse(data.AssumeRoleResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryAssumeRoleCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ExpiredTokenException":
+        case "com.amazonaws.sts#ExpiredTokenException":
+            throw await deserializeAws_queryExpiredTokenExceptionResponse(parsedOutput, context);
+        case "MalformedPolicyDocument":
+        case "com.amazonaws.sts#MalformedPolicyDocumentException":
+            throw await deserializeAws_queryMalformedPolicyDocumentExceptionResponse(parsedOutput, context);
+        case "PackedPolicyTooLarge":
+        case "com.amazonaws.sts#PackedPolicyTooLargeException":
+            throw await deserializeAws_queryPackedPolicyTooLargeExceptionResponse(parsedOutput, context);
+        case "RegionDisabledException":
+        case "com.amazonaws.sts#RegionDisabledException":
+            throw await deserializeAws_queryRegionDisabledExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody: parsedBody.Error,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_queryAssumeRoleWithSAMLCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryAssumeRoleWithSAMLCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryAssumeRoleWithSAMLResponse(data.AssumeRoleWithSAMLResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryAssumeRoleWithSAMLCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ExpiredTokenException":
+        case "com.amazonaws.sts#ExpiredTokenException":
+            throw await deserializeAws_queryExpiredTokenExceptionResponse(parsedOutput, context);
+        case "IDPRejectedClaim":
+        case "com.amazonaws.sts#IDPRejectedClaimException":
+            throw await deserializeAws_queryIDPRejectedClaimExceptionResponse(parsedOutput, context);
+        case "InvalidIdentityToken":
+        case "com.amazonaws.sts#InvalidIdentityTokenException":
+            throw await deserializeAws_queryInvalidIdentityTokenExceptionResponse(parsedOutput, context);
+        case "MalformedPolicyDocument":
+        case "com.amazonaws.sts#MalformedPolicyDocumentException":
+            throw await deserializeAws_queryMalformedPolicyDocumentExceptionResponse(parsedOutput, context);
+        case "PackedPolicyTooLarge":
+        case "com.amazonaws.sts#PackedPolicyTooLargeException":
+            throw await deserializeAws_queryPackedPolicyTooLargeExceptionResponse(parsedOutput, context);
+        case "RegionDisabledException":
+        case "com.amazonaws.sts#RegionDisabledException":
+            throw await deserializeAws_queryRegionDisabledExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody: parsedBody.Error,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_queryAssumeRoleWithWebIdentityCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryAssumeRoleWithWebIdentityCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryAssumeRoleWithWebIdentityResponse(data.AssumeRoleWithWebIdentityResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryAssumeRoleWithWebIdentityCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ExpiredTokenException":
+        case "com.amazonaws.sts#ExpiredTokenException":
+            throw await deserializeAws_queryExpiredTokenExceptionResponse(parsedOutput, context);
+        case "IDPCommunicationError":
+        case "com.amazonaws.sts#IDPCommunicationErrorException":
+            throw await deserializeAws_queryIDPCommunicationErrorExceptionResponse(parsedOutput, context);
+        case "IDPRejectedClaim":
+        case "com.amazonaws.sts#IDPRejectedClaimException":
+            throw await deserializeAws_queryIDPRejectedClaimExceptionResponse(parsedOutput, context);
+        case "InvalidIdentityToken":
+        case "com.amazonaws.sts#InvalidIdentityTokenException":
+            throw await deserializeAws_queryInvalidIdentityTokenExceptionResponse(parsedOutput, context);
+        case "MalformedPolicyDocument":
+        case "com.amazonaws.sts#MalformedPolicyDocumentException":
+            throw await deserializeAws_queryMalformedPolicyDocumentExceptionResponse(parsedOutput, context);
+        case "PackedPolicyTooLarge":
+        case "com.amazonaws.sts#PackedPolicyTooLargeException":
+            throw await deserializeAws_queryPackedPolicyTooLargeExceptionResponse(parsedOutput, context);
+        case "RegionDisabledException":
+        case "com.amazonaws.sts#RegionDisabledException":
+            throw await deserializeAws_queryRegionDisabledExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody: parsedBody.Error,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_queryDecodeAuthorizationMessageCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryDecodeAuthorizationMessageCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryDecodeAuthorizationMessageResponse(data.DecodeAuthorizationMessageResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryDecodeAuthorizationMessageCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidAuthorizationMessageException":
+        case "com.amazonaws.sts#InvalidAuthorizationMessageException":
+            throw await deserializeAws_queryInvalidAuthorizationMessageExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody: parsedBody.Error,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_queryGetAccessKeyInfoCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryGetAccessKeyInfoCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryGetAccessKeyInfoResponse(data.GetAccessKeyInfoResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryGetAccessKeyInfoCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
     });
-}); };
-var deserializeAws_queryGetSessionTokenCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var parsedOutput, _a, errorCode, _b, parsedBody;
-    var _c;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
-            case 0:
-                _a = [__assign({}, output)];
-                _c = {};
-                return [4, parseErrorBody(output.body, context)];
-            case 1:
-                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
-                errorCode = loadQueryErrorCode(output, parsedOutput.body);
-                _b = errorCode;
-                switch (_b) {
-                    case "RegionDisabledException": return [3, 2];
-                    case "com.amazonaws.sts#RegionDisabledException": return [3, 2];
-                }
-                return [3, 4];
-            case 2: return [4, deserializeAws_queryRegionDisabledExceptionResponse(parsedOutput, context)];
-            case 3: throw _d.sent();
-            case 4:
-                parsedBody = parsedOutput.body;
-                throwDefaultError({
-                    output: output,
-                    parsedBody: parsedBody.Error,
-                    exceptionCtor: __BaseException,
-                    errorCode: errorCode,
-                });
-                _d.label = 5;
-            case 5: return [2];
-        }
+};
+export const deserializeAws_queryGetCallerIdentityCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryGetCallerIdentityCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryGetCallerIdentityResponse(data.GetCallerIdentityResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryGetCallerIdentityCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
     });
-}); };
-var deserializeAws_queryExpiredTokenExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var body, deserialized, exception;
-    return __generator(this, function (_a) {
-        body = parsedOutput.body;
-        deserialized = deserializeAws_queryExpiredTokenException(body.Error, context);
-        exception = new ExpiredTokenException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
-        return [2, __decorateServiceException(exception, body)];
+};
+export const deserializeAws_queryGetFederationTokenCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryGetFederationTokenCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryGetFederationTokenResponse(data.GetFederationTokenResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryGetFederationTokenCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "MalformedPolicyDocument":
+        case "com.amazonaws.sts#MalformedPolicyDocumentException":
+            throw await deserializeAws_queryMalformedPolicyDocumentExceptionResponse(parsedOutput, context);
+        case "PackedPolicyTooLarge":
+        case "com.amazonaws.sts#PackedPolicyTooLargeException":
+            throw await deserializeAws_queryPackedPolicyTooLargeExceptionResponse(parsedOutput, context);
+        case "RegionDisabledException":
+        case "com.amazonaws.sts#RegionDisabledException":
+            throw await deserializeAws_queryRegionDisabledExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody: parsedBody.Error,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_queryGetSessionTokenCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryGetSessionTokenCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryGetSessionTokenResponse(data.GetSessionTokenResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryGetSessionTokenCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "RegionDisabledException":
+        case "com.amazonaws.sts#RegionDisabledException":
+            throw await deserializeAws_queryRegionDisabledExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody: parsedBody.Error,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_queryExpiredTokenExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_queryExpiredTokenException(body.Error, context);
+    const exception = new ExpiredTokenException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-}); };
-var deserializeAws_queryIDPCommunicationErrorExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var body, deserialized, exception;
-    return __generator(this, function (_a) {
-        body = parsedOutput.body;
-        deserialized = deserializeAws_queryIDPCommunicationErrorException(body.Error, context);
-        exception = new IDPCommunicationErrorException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
-        return [2, __decorateServiceException(exception, body)];
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_queryIDPCommunicationErrorExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_queryIDPCommunicationErrorException(body.Error, context);
+    const exception = new IDPCommunicationErrorException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-}); };
-var deserializeAws_queryIDPRejectedClaimExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var body, deserialized, exception;
-    return __generator(this, function (_a) {
-        body = parsedOutput.body;
-        deserialized = deserializeAws_queryIDPRejectedClaimException(body.Error, context);
-        exception = new IDPRejectedClaimException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
-        return [2, __decorateServiceException(exception, body)];
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_queryIDPRejectedClaimExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_queryIDPRejectedClaimException(body.Error, context);
+    const exception = new IDPRejectedClaimException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-}); };
-var deserializeAws_queryInvalidAuthorizationMessageExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var body, deserialized, exception;
-    return __generator(this, function (_a) {
-        body = parsedOutput.body;
-        deserialized = deserializeAws_queryInvalidAuthorizationMessageException(body.Error, context);
-        exception = new InvalidAuthorizationMessageException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
-        return [2, __decorateServiceException(exception, body)];
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_queryInvalidAuthorizationMessageExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_queryInvalidAuthorizationMessageException(body.Error, context);
+    const exception = new InvalidAuthorizationMessageException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-}); };
-var deserializeAws_queryInvalidIdentityTokenExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var body, deserialized, exception;
-    return __generator(this, function (_a) {
-        body = parsedOutput.body;
-        deserialized = deserializeAws_queryInvalidIdentityTokenException(body.Error, context);
-        exception = new InvalidIdentityTokenException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
-        return [2, __decorateServiceException(exception, body)];
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_queryInvalidIdentityTokenExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_queryInvalidIdentityTokenException(body.Error, context);
+    const exception = new InvalidIdentityTokenException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-}); };
-var deserializeAws_queryMalformedPolicyDocumentExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var body, deserialized, exception;
-    return __generator(this, function (_a) {
-        body = parsedOutput.body;
-        deserialized = deserializeAws_queryMalformedPolicyDocumentException(body.Error, context);
-        exception = new MalformedPolicyDocumentException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
-        return [2, __decorateServiceException(exception, body)];
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_queryMalformedPolicyDocumentExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_queryMalformedPolicyDocumentException(body.Error, context);
+    const exception = new MalformedPolicyDocumentException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-}); };
-var deserializeAws_queryPackedPolicyTooLargeExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var body, deserialized, exception;
-    return __generator(this, function (_a) {
-        body = parsedOutput.body;
-        deserialized = deserializeAws_queryPackedPolicyTooLargeException(body.Error, context);
-        exception = new PackedPolicyTooLargeException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
-        return [2, __decorateServiceException(exception, body)];
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_queryPackedPolicyTooLargeExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_queryPackedPolicyTooLargeException(body.Error, context);
+    const exception = new PackedPolicyTooLargeException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-}); };
-var deserializeAws_queryRegionDisabledExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var body, deserialized, exception;
-    return __generator(this, function (_a) {
-        body = parsedOutput.body;
-        deserialized = deserializeAws_queryRegionDisabledException(body.Error, context);
-        exception = new RegionDisabledException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
-        return [2, __decorateServiceException(exception, body)];
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_queryRegionDisabledExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_queryRegionDisabledException(body.Error, context);
+    const exception = new RegionDisabledException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-}); };
-var serializeAws_queryAssumeRoleRequest = function (input, context) {
-    var entries = {};
+    return __decorateServiceException(exception, body);
+};
+const serializeAws_queryAssumeRoleRequest = (input, context) => {
+    const entries = {};
     if (input.RoleArn != null) {
         entries["RoleArn"] = input.RoleArn;
     }
@@ -618,10 +480,9 @@ var serializeAws_queryAssumeRoleRequest = function (input, context) {
         entries["RoleSessionName"] = input.RoleSessionName;
     }
     if (input.PolicyArns != null) {
-        var memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
-        Object.entries(memberEntries).forEach(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            var loc = "PolicyArns.".concat(key);
+        const memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `PolicyArns.${key}`;
             entries[loc] = value;
         });
     }
@@ -632,18 +493,16 @@ var serializeAws_queryAssumeRoleRequest = function (input, context) {
         entries["DurationSeconds"] = input.DurationSeconds;
     }
     if (input.Tags != null) {
-        var memberEntries = serializeAws_querytagListType(input.Tags, context);
-        Object.entries(memberEntries).forEach(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            var loc = "Tags.".concat(key);
+        const memberEntries = serializeAws_querytagListType(input.Tags, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Tags.${key}`;
             entries[loc] = value;
         });
     }
     if (input.TransitiveTagKeys != null) {
-        var memberEntries = serializeAws_querytagKeyListType(input.TransitiveTagKeys, context);
-        Object.entries(memberEntries).forEach(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            var loc = "TransitiveTagKeys.".concat(key);
+        const memberEntries = serializeAws_querytagKeyListType(input.TransitiveTagKeys, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TransitiveTagKeys.${key}`;
             entries[loc] = value;
         });
     }
@@ -661,8 +520,8 @@ var serializeAws_queryAssumeRoleRequest = function (input, context) {
     }
     return entries;
 };
-var serializeAws_queryAssumeRoleWithSAMLRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryAssumeRoleWithSAMLRequest = (input, context) => {
+    const entries = {};
     if (input.RoleArn != null) {
         entries["RoleArn"] = input.RoleArn;
     }
@@ -673,10 +532,9 @@ var serializeAws_queryAssumeRoleWithSAMLRequest = function (input, context) {
         entries["SAMLAssertion"] = input.SAMLAssertion;
     }
     if (input.PolicyArns != null) {
-        var memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
-        Object.entries(memberEntries).forEach(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            var loc = "PolicyArns.".concat(key);
+        const memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `PolicyArns.${key}`;
             entries[loc] = value;
         });
     }
@@ -688,8 +546,8 @@ var serializeAws_queryAssumeRoleWithSAMLRequest = function (input, context) {
     }
     return entries;
 };
-var serializeAws_queryAssumeRoleWithWebIdentityRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryAssumeRoleWithWebIdentityRequest = (input, context) => {
+    const entries = {};
     if (input.RoleArn != null) {
         entries["RoleArn"] = input.RoleArn;
     }
@@ -703,10 +561,9 @@ var serializeAws_queryAssumeRoleWithWebIdentityRequest = function (input, contex
         entries["ProviderId"] = input.ProviderId;
     }
     if (input.PolicyArns != null) {
-        var memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
-        Object.entries(memberEntries).forEach(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            var loc = "PolicyArns.".concat(key);
+        const memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `PolicyArns.${key}`;
             entries[loc] = value;
         });
     }
@@ -718,26 +575,26 @@ var serializeAws_queryAssumeRoleWithWebIdentityRequest = function (input, contex
     }
     return entries;
 };
-var serializeAws_queryDecodeAuthorizationMessageRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryDecodeAuthorizationMessageRequest = (input, context) => {
+    const entries = {};
     if (input.EncodedMessage != null) {
         entries["EncodedMessage"] = input.EncodedMessage;
     }
     return entries;
 };
-var serializeAws_queryGetAccessKeyInfoRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryGetAccessKeyInfoRequest = (input, context) => {
+    const entries = {};
     if (input.AccessKeyId != null) {
         entries["AccessKeyId"] = input.AccessKeyId;
     }
     return entries;
 };
-var serializeAws_queryGetCallerIdentityRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryGetCallerIdentityRequest = (input, context) => {
+    const entries = {};
     return entries;
 };
-var serializeAws_queryGetFederationTokenRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryGetFederationTokenRequest = (input, context) => {
+    const entries = {};
     if (input.Name != null) {
         entries["Name"] = input.Name;
     }
@@ -745,10 +602,9 @@ var serializeAws_queryGetFederationTokenRequest = function (input, context) {
         entries["Policy"] = input.Policy;
     }
     if (input.PolicyArns != null) {
-        var memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
-        Object.entries(memberEntries).forEach(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            var loc = "PolicyArns.".concat(key);
+        const memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `PolicyArns.${key}`;
             entries[loc] = value;
         });
     }
@@ -756,17 +612,16 @@ var serializeAws_queryGetFederationTokenRequest = function (input, context) {
         entries["DurationSeconds"] = input.DurationSeconds;
     }
     if (input.Tags != null) {
-        var memberEntries = serializeAws_querytagListType(input.Tags, context);
-        Object.entries(memberEntries).forEach(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            var loc = "Tags.".concat(key);
+        const memberEntries = serializeAws_querytagListType(input.Tags, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Tags.${key}`;
             entries[loc] = value;
         });
     }
     return entries;
 };
-var serializeAws_queryGetSessionTokenRequest = function (input, context) {
-    var entries = {};
+const serializeAws_queryGetSessionTokenRequest = (input, context) => {
+    const entries = {};
     if (input.DurationSeconds != null) {
         entries["DurationSeconds"] = input.DurationSeconds;
     }
@@ -778,42 +633,30 @@ var serializeAws_queryGetSessionTokenRequest = function (input, context) {
     }
     return entries;
 };
-var serializeAws_querypolicyDescriptorListType = function (input, context) {
-    var e_1, _a;
-    var entries = {};
-    var counter = 1;
-    try {
-        for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
-            var entry = input_1_1.value;
-            if (entry === null) {
-                continue;
-            }
-            var memberEntries = serializeAws_queryPolicyDescriptorType(entry, context);
-            Object.entries(memberEntries).forEach(function (_a) {
-                var _b = __read(_a, 2), key = _b[0], value = _b[1];
-                entries["member.".concat(counter, ".").concat(key)] = value;
-            });
-            counter++;
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (input_1_1 && !input_1_1.done && (_a = input_1.return)) _a.call(input_1);
+const serializeAws_querypolicyDescriptorListType = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-        finally { if (e_1) throw e_1.error; }
+        const memberEntries = serializeAws_queryPolicyDescriptorType(entry, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            entries[`member.${counter}.${key}`] = value;
+        });
+        counter++;
     }
     return entries;
 };
-var serializeAws_queryPolicyDescriptorType = function (input, context) {
-    var entries = {};
+const serializeAws_queryPolicyDescriptorType = (input, context) => {
+    const entries = {};
     if (input.arn != null) {
         entries["arn"] = input.arn;
     }
     return entries;
 };
-var serializeAws_queryTag = function (input, context) {
-    var entries = {};
+const serializeAws_queryTag = (input, context) => {
+    const entries = {};
     if (input.Key != null) {
         entries["Key"] = input.Key;
     }
@@ -822,58 +665,35 @@ var serializeAws_queryTag = function (input, context) {
     }
     return entries;
 };
-var serializeAws_querytagKeyListType = function (input, context) {
-    var e_2, _a;
-    var entries = {};
-    var counter = 1;
-    try {
-        for (var input_2 = __values(input), input_2_1 = input_2.next(); !input_2_1.done; input_2_1 = input_2.next()) {
-            var entry = input_2_1.value;
-            if (entry === null) {
-                continue;
-            }
-            entries["member.".concat(counter)] = entry;
-            counter++;
-        }
-    }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
-        try {
-            if (input_2_1 && !input_2_1.done && (_a = input_2.return)) _a.call(input_2);
+const serializeAws_querytagKeyListType = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-        finally { if (e_2) throw e_2.error; }
+        entries[`member.${counter}`] = entry;
+        counter++;
     }
     return entries;
 };
-var serializeAws_querytagListType = function (input, context) {
-    var e_3, _a;
-    var entries = {};
-    var counter = 1;
-    try {
-        for (var input_3 = __values(input), input_3_1 = input_3.next(); !input_3_1.done; input_3_1 = input_3.next()) {
-            var entry = input_3_1.value;
-            if (entry === null) {
-                continue;
-            }
-            var memberEntries = serializeAws_queryTag(entry, context);
-            Object.entries(memberEntries).forEach(function (_a) {
-                var _b = __read(_a, 2), key = _b[0], value = _b[1];
-                entries["member.".concat(counter, ".").concat(key)] = value;
-            });
-            counter++;
+const serializeAws_querytagListType = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
         }
-    }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-    finally {
-        try {
-            if (input_3_1 && !input_3_1.done && (_a = input_3.return)) _a.call(input_3);
-        }
-        finally { if (e_3) throw e_3.error; }
+        const memberEntries = serializeAws_queryTag(entry, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            entries[`member.${counter}.${key}`] = value;
+        });
+        counter++;
     }
     return entries;
 };
-var deserializeAws_queryAssumedRoleUser = function (output, context) {
-    var contents = {
+const deserializeAws_queryAssumedRoleUser = (output, context) => {
+    const contents = {
         AssumedRoleId: undefined,
         Arn: undefined,
     };
@@ -885,8 +705,8 @@ var deserializeAws_queryAssumedRoleUser = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryAssumeRoleResponse = function (output, context) {
-    var contents = {
+const deserializeAws_queryAssumeRoleResponse = (output, context) => {
+    const contents = {
         Credentials: undefined,
         AssumedRoleUser: undefined,
         PackedPolicySize: undefined,
@@ -906,8 +726,8 @@ var deserializeAws_queryAssumeRoleResponse = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryAssumeRoleWithSAMLResponse = function (output, context) {
-    var contents = {
+const deserializeAws_queryAssumeRoleWithSAMLResponse = (output, context) => {
+    const contents = {
         Credentials: undefined,
         AssumedRoleUser: undefined,
         PackedPolicySize: undefined,
@@ -947,8 +767,8 @@ var deserializeAws_queryAssumeRoleWithSAMLResponse = function (output, context)
     }
     return contents;
 };
-var deserializeAws_queryAssumeRoleWithWebIdentityResponse = function (output, context) {
-    var contents = {
+const deserializeAws_queryAssumeRoleWithWebIdentityResponse = (output, context) => {
+    const contents = {
         Credentials: undefined,
         SubjectFromWebIdentityToken: undefined,
         AssumedRoleUser: undefined,
@@ -980,8 +800,8 @@ var deserializeAws_queryAssumeRoleWithWebIdentityResponse = function (output, co
     }
     return contents;
 };
-var deserializeAws_queryCredentials = function (output, context) {
-    var contents = {
+const deserializeAws_queryCredentials = (output, context) => {
+    const contents = {
         AccessKeyId: undefined,
         SecretAccessKey: undefined,
         SessionToken: undefined,
@@ -1001,8 +821,8 @@ var deserializeAws_queryCredentials = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryDecodeAuthorizationMessageResponse = function (output, context) {
-    var contents = {
+const deserializeAws_queryDecodeAuthorizationMessageResponse = (output, context) => {
+    const contents = {
         DecodedMessage: undefined,
     };
     if (output["DecodedMessage"] !== undefined) {
@@ -1010,8 +830,8 @@ var deserializeAws_queryDecodeAuthorizationMessageResponse = function (output, c
     }
     return contents;
 };
-var deserializeAws_queryExpiredTokenException = function (output, context) {
-    var contents = {
+const deserializeAws_queryExpiredTokenException = (output, context) => {
+    const contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -1019,8 +839,8 @@ var deserializeAws_queryExpiredTokenException = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryFederatedUser = function (output, context) {
-    var contents = {
+const deserializeAws_queryFederatedUser = (output, context) => {
+    const contents = {
         FederatedUserId: undefined,
         Arn: undefined,
     };
@@ -1032,8 +852,8 @@ var deserializeAws_queryFederatedUser = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryGetAccessKeyInfoResponse = function (output, context) {
-    var contents = {
+const deserializeAws_queryGetAccessKeyInfoResponse = (output, context) => {
+    const contents = {
         Account: undefined,
     };
     if (output["Account"] !== undefined) {
@@ -1041,8 +861,8 @@ var deserializeAws_queryGetAccessKeyInfoResponse = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryGetCallerIdentityResponse = function (output, context) {
-    var contents = {
+const deserializeAws_queryGetCallerIdentityResponse = (output, context) => {
+    const contents = {
         UserId: undefined,
         Account: undefined,
         Arn: undefined,
@@ -1058,8 +878,8 @@ var deserializeAws_queryGetCallerIdentityResponse = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryGetFederationTokenResponse = function (output, context) {
-    var contents = {
+const deserializeAws_queryGetFederationTokenResponse = (output, context) => {
+    const contents = {
         Credentials: undefined,
         FederatedUser: undefined,
         PackedPolicySize: undefined,
@@ -1075,8 +895,8 @@ var deserializeAws_queryGetFederationTokenResponse = function (output, context)
     }
     return contents;
 };
-var deserializeAws_queryGetSessionTokenResponse = function (output, context) {
-    var contents = {
+const deserializeAws_queryGetSessionTokenResponse = (output, context) => {
+    const contents = {
         Credentials: undefined,
     };
     if (output["Credentials"] !== undefined) {
@@ -1084,8 +904,8 @@ var deserializeAws_queryGetSessionTokenResponse = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryIDPCommunicationErrorException = function (output, context) {
-    var contents = {
+const deserializeAws_queryIDPCommunicationErrorException = (output, context) => {
+    const contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -1093,8 +913,8 @@ var deserializeAws_queryIDPCommunicationErrorException = function (output, conte
     }
     return contents;
 };
-var deserializeAws_queryIDPRejectedClaimException = function (output, context) {
-    var contents = {
+const deserializeAws_queryIDPRejectedClaimException = (output, context) => {
+    const contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -1102,8 +922,8 @@ var deserializeAws_queryIDPRejectedClaimException = function (output, context) {
     }
     return contents;
 };
-var deserializeAws_queryInvalidAuthorizationMessageException = function (output, context) {
-    var contents = {
+const deserializeAws_queryInvalidAuthorizationMessageException = (output, context) => {
+    const contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -1111,8 +931,8 @@ var deserializeAws_queryInvalidAuthorizationMessageException = function (output,
     }
     return contents;
 };
-var deserializeAws_queryInvalidIdentityTokenException = function (output, context) {
-    var contents = {
+const deserializeAws_queryInvalidIdentityTokenException = (output, context) => {
+    const contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -1120,8 +940,8 @@ var deserializeAws_queryInvalidIdentityTokenException = function (output, contex
     }
     return contents;
 };
-var deserializeAws_queryMalformedPolicyDocumentException = function (output, context) {
-    var contents = {
+const deserializeAws_queryMalformedPolicyDocumentException = (output, context) => {
+    const contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -1129,8 +949,8 @@ var deserializeAws_queryMalformedPolicyDocumentException = function (output, con
     }
     return contents;
 };
-var deserializeAws_queryPackedPolicyTooLargeException = function (output, context) {
-    var contents = {
+const deserializeAws_queryPackedPolicyTooLargeException = (output, context) => {
+    const contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -1138,8 +958,8 @@ var deserializeAws_queryPackedPolicyTooLargeException = function (output, contex
     }
     return contents;
 };
-var deserializeAws_queryRegionDisabledException = function (output, context) {
-    var contents = {
+const deserializeAws_queryRegionDisabledException = (output, context) => {
+    const contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -1147,96 +967,73 @@ var deserializeAws_queryRegionDisabledException = function (output, context) {
     }
     return contents;
 };
-var deserializeMetadata = function (output) {
-    var _a, _b;
-    return ({
-        httpStatusCode: output.statusCode,
-        requestId: (_b = (_a = output.headers["x-amzn-requestid"]) !== null && _a !== void 0 ? _a : output.headers["x-amzn-request-id"]) !== null && _b !== void 0 ? _b : output.headers["x-amz-request-id"],
-        extendedRequestId: output.headers["x-amz-id-2"],
-        cfId: output.headers["x-amz-cf-id"],
-    });
-};
-var collectBody = function (streamBody, context) {
-    if (streamBody === void 0) { streamBody = new Uint8Array(); }
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const collectBody = (streamBody = new Uint8Array(), context) => {
     if (streamBody instanceof Uint8Array) {
         return Promise.resolve(streamBody);
     }
     return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
 };
-var collectBodyString = function (streamBody, context) {
-    return collectBody(streamBody, context).then(function (body) { return context.utf8Encoder(body); });
-};
-var buildHttpRpcRequest = function (context, headers, path, resolvedHostname, body) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, hostname, _b, protocol, port, basePath, contents;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0: return [4, context.endpoint()];
-            case 1:
-                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
-                contents = {
-                    protocol: protocol,
-                    hostname: hostname,
-                    port: port,
-                    method: "POST",
-                    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-                    headers: headers,
-                };
-                if (resolvedHostname !== undefined) {
-                    contents.hostname = resolvedHostname;
-                }
-                if (body !== undefined) {
-                    contents.body = body;
-                }
-                return [2, new __HttpRequest(contents)];
-        }
-    });
-}); };
-var parseBody = function (streamBody, context) {
-    return collectBodyString(streamBody, context).then(function (encoded) {
-        if (encoded.length) {
-            var parsedObj = xmlParse(encoded, {
-                attributeNamePrefix: "",
-                ignoreAttributes: false,
-                parseNodeValue: false,
-                trimValues: false,
-                tagValueProcessor: function (val) { return (val.trim() === "" && val.includes("\n") ? "" : decodeHTML(val)); },
-            });
-            var textNodeName = "#text";
-            var key = Object.keys(parsedObj)[0];
-            var parsedObjToReturn = parsedObj[key];
-            if (parsedObjToReturn[textNodeName]) {
-                parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
-                delete parsedObjToReturn[textNodeName];
-            }
-            return __getValueFromTextNode(parsedObjToReturn);
-        }
-        return {};
-    });
+const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const contents = {
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+        headers,
+    };
+    if (resolvedHostname !== undefined) {
+        contents.hostname = resolvedHostname;
+    }
+    if (body !== undefined) {
+        contents.body = body;
+    }
+    return new __HttpRequest(contents);
 };
-var parseErrorBody = function (errorBody, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var value;
-    var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0: return [4, parseBody(errorBody, context)];
-            case 1:
-                value = _b.sent();
-                if (value.Error) {
-                    value.Error.message = (_a = value.Error.message) !== null && _a !== void 0 ? _a : value.Error.Message;
-                }
-                return [2, value];
+const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+    if (encoded.length) {
+        const parser = new XMLParser({
+            attributeNamePrefix: "",
+            htmlEntities: true,
+            ignoreAttributes: false,
+            ignoreDeclaration: true,
+            parseTagValue: false,
+            trimValues: false,
+            tagValueProcessor: (_, val) => (val.trim() === "" && val.includes("\n") ? "" : undefined),
+        });
+        parser.addEntity("#xD", "\r");
+        parser.addEntity("#10", "\n");
+        const parsedObj = parser.parse(encoded);
+        const textNodeName = "#text";
+        const key = Object.keys(parsedObj)[0];
+        const parsedObjToReturn = parsedObj[key];
+        if (parsedObjToReturn[textNodeName]) {
+            parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
+            delete parsedObjToReturn[textNodeName];
         }
-    });
-}); };
-var buildFormUrlencodedString = function (formEntries) {
-    return Object.entries(formEntries)
-        .map(function (_a) {
-        var _b = __read(_a, 2), key = _b[0], value = _b[1];
-        return __extendedEncodeURIComponent(key) + "=" + __extendedEncodeURIComponent(value);
-    })
-        .join("&");
-};
-var loadQueryErrorCode = function (output, data) {
+        return __getValueFromTextNode(parsedObjToReturn);
+    }
+    return {};
+});
+const parseErrorBody = async (errorBody, context) => {
+    const value = await parseBody(errorBody, context);
+    if (value.Error) {
+        value.Error.message = value.Error.message ?? value.Error.Message;
+    }
+    return value;
+};
+const buildFormUrlencodedString = (formEntries) => Object.entries(formEntries)
+    .map(([key, value]) => __extendedEncodeURIComponent(key) + "=" + __extendedEncodeURIComponent(value))
+    .join("&");
+const loadQueryErrorCode = (output, data) => {
     if (data.Error.Code !== undefined) {
         return data.Error.Code;
     }