@aws-sdk/client-sts 3.183.0 → 3.186.0

package/dist-es/protocols/Aws_query.js

@@ -1,479 +1,616 @@
+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 { ExpiredTokenException, IDPCommunicationErrorException, IDPRejectedClaimException, InvalidAuthorizationMessageException, InvalidIdentityTokenException, MalformedPolicyDocumentException, PackedPolicyTooLargeException, RegionDisabledException, } from "../models/models_0";
 import { STSServiceException as __BaseException } from "../models/STSServiceException";
-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",
+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)];
     });
-    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 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)];
     });
-    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",
+}); };
+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)];
     });
-    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 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)];
     });
-    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",
+}); };
+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)];
     });
-    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 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)];
     });
-    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",
+}); };
+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)];
     });
-    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 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)];
     });
-    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,
+}); };
+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)];
+        }
     });
-};
-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_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 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,
+}); };
+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)];
+        }
     });
-    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_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];
+        }
     });
-    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,
+}); };
+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)];
+        }
     });
-    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_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];
+        }
     });
-    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,
+}); };
+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)];
+        }
     });
-    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_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 __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,
+}); };
+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 __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 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 __decorateServiceException(exception, body);
-};
-const serializeAws_queryAssumeRoleRequest = (input, context) => {
-    const entries = {};
+}); };
+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)];
+        }
+    });
+}); };
+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];
+        }
+    });
+}); };
+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)];
+        }
+    });
+}); };
+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];
+        }
+    });
+}); };
+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)];
+        }
+    });
+}); };
+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];
+        }
+    });
+}); };
+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)];
+    });
+}); };
+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)];
+    });
+}); };
+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)];
+    });
+}); };
+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)];
+    });
+}); };
+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)];
+    });
+}); };
+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)];
+    });
+}); };
+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)];
+    });
+}); };
+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)];
+    });
+}); };
+var serializeAws_queryAssumeRoleRequest = function (input, context) {
+    var entries = {};
     if (input.RoleArn != null) {
         entries["RoleArn"] = input.RoleArn;
     }
@@ -481,9 +618,10 @@ const serializeAws_queryAssumeRoleRequest = (input, context) => {
         entries["RoleSessionName"] = input.RoleSessionName;
     }
     if (input.PolicyArns != null) {
-        const memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `PolicyArns.${key}`;
+        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);
             entries[loc] = value;
         });
     }
@@ -494,16 +632,18 @@ const serializeAws_queryAssumeRoleRequest = (input, context) => {
         entries["DurationSeconds"] = input.DurationSeconds;
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_querytagListType(input.Tags, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Tags.${key}`;
+        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);
             entries[loc] = value;
         });
     }
     if (input.TransitiveTagKeys != null) {
-        const memberEntries = serializeAws_querytagKeyListType(input.TransitiveTagKeys, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `TransitiveTagKeys.${key}`;
+        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);
             entries[loc] = value;
         });
     }
@@ -521,8 +661,8 @@ const serializeAws_queryAssumeRoleRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAssumeRoleWithSAMLRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryAssumeRoleWithSAMLRequest = function (input, context) {
+    var entries = {};
     if (input.RoleArn != null) {
         entries["RoleArn"] = input.RoleArn;
     }
@@ -533,9 +673,10 @@ const serializeAws_queryAssumeRoleWithSAMLRequest = (input, context) => {
         entries["SAMLAssertion"] = input.SAMLAssertion;
     }
     if (input.PolicyArns != null) {
-        const memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `PolicyArns.${key}`;
+        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);
             entries[loc] = value;
         });
     }
@@ -547,8 +688,8 @@ const serializeAws_queryAssumeRoleWithSAMLRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryAssumeRoleWithWebIdentityRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryAssumeRoleWithWebIdentityRequest = function (input, context) {
+    var entries = {};
     if (input.RoleArn != null) {
         entries["RoleArn"] = input.RoleArn;
     }
@@ -562,9 +703,10 @@ const serializeAws_queryAssumeRoleWithWebIdentityRequest = (input, context) => {
         entries["ProviderId"] = input.ProviderId;
     }
     if (input.PolicyArns != null) {
-        const memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `PolicyArns.${key}`;
+        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);
             entries[loc] = value;
         });
     }
@@ -576,26 +718,26 @@ const serializeAws_queryAssumeRoleWithWebIdentityRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_queryDecodeAuthorizationMessageRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryDecodeAuthorizationMessageRequest = function (input, context) {
+    var entries = {};
     if (input.EncodedMessage != null) {
         entries["EncodedMessage"] = input.EncodedMessage;
     }
     return entries;
 };
-const serializeAws_queryGetAccessKeyInfoRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryGetAccessKeyInfoRequest = function (input, context) {
+    var entries = {};
     if (input.AccessKeyId != null) {
         entries["AccessKeyId"] = input.AccessKeyId;
     }
     return entries;
 };
-const serializeAws_queryGetCallerIdentityRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryGetCallerIdentityRequest = function (input, context) {
+    var entries = {};
     return entries;
 };
-const serializeAws_queryGetFederationTokenRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryGetFederationTokenRequest = function (input, context) {
+    var entries = {};
     if (input.Name != null) {
         entries["Name"] = input.Name;
     }
@@ -603,9 +745,10 @@ const serializeAws_queryGetFederationTokenRequest = (input, context) => {
         entries["Policy"] = input.Policy;
     }
     if (input.PolicyArns != null) {
-        const memberEntries = serializeAws_querypolicyDescriptorListType(input.PolicyArns, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `PolicyArns.${key}`;
+        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);
             entries[loc] = value;
         });
     }
@@ -613,16 +756,17 @@ const serializeAws_queryGetFederationTokenRequest = (input, context) => {
         entries["DurationSeconds"] = input.DurationSeconds;
     }
     if (input.Tags != null) {
-        const memberEntries = serializeAws_querytagListType(input.Tags, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `Tags.${key}`;
+        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);
             entries[loc] = value;
         });
     }
     return entries;
 };
-const serializeAws_queryGetSessionTokenRequest = (input, context) => {
-    const entries = {};
+var serializeAws_queryGetSessionTokenRequest = function (input, context) {
+    var entries = {};
     if (input.DurationSeconds != null) {
         entries["DurationSeconds"] = input.DurationSeconds;
     }
@@ -634,30 +778,42 @@ const serializeAws_queryGetSessionTokenRequest = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querypolicyDescriptorListType = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+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++;
         }
-        const memberEntries = serializeAws_queryPolicyDescriptorType(entry, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${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);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
     return entries;
 };
-const serializeAws_queryPolicyDescriptorType = (input, context) => {
-    const entries = {};
+var serializeAws_queryPolicyDescriptorType = function (input, context) {
+    var entries = {};
     if (input.arn != null) {
         entries["arn"] = input.arn;
     }
     return entries;
 };
-const serializeAws_queryTag = (input, context) => {
-    const entries = {};
+var serializeAws_queryTag = function (input, context) {
+    var entries = {};
     if (input.Key != null) {
         entries["Key"] = input.Key;
     }
@@ -666,35 +822,58 @@ const serializeAws_queryTag = (input, context) => {
     }
     return entries;
 };
-const serializeAws_querytagKeyListType = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+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);
         }
-        entries[`member.${counter}`] = entry;
-        counter++;
+        finally { if (e_2) throw e_2.error; }
     }
     return entries;
 };
-const serializeAws_querytagListType = (input, context) => {
-    const entries = {};
-    let counter = 1;
-    for (const entry of input) {
-        if (entry === null) {
-            continue;
+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 memberEntries = serializeAws_queryTag(entry, context);
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            entries[`member.${counter}.${key}`] = value;
-        });
-        counter++;
+    }
+    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; }
     }
     return entries;
 };
-const deserializeAws_queryAssumedRoleUser = (output, context) => {
-    const contents = {
+var deserializeAws_queryAssumedRoleUser = function (output, context) {
+    var contents = {
         AssumedRoleId: undefined,
         Arn: undefined,
     };
@@ -706,8 +885,8 @@ const deserializeAws_queryAssumedRoleUser = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryAssumeRoleResponse = (output, context) => {
-    const contents = {
+var deserializeAws_queryAssumeRoleResponse = function (output, context) {
+    var contents = {
         Credentials: undefined,
         AssumedRoleUser: undefined,
         PackedPolicySize: undefined,
@@ -727,8 +906,8 @@ const deserializeAws_queryAssumeRoleResponse = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryAssumeRoleWithSAMLResponse = (output, context) => {
-    const contents = {
+var deserializeAws_queryAssumeRoleWithSAMLResponse = function (output, context) {
+    var contents = {
         Credentials: undefined,
         AssumedRoleUser: undefined,
         PackedPolicySize: undefined,
@@ -768,8 +947,8 @@ const deserializeAws_queryAssumeRoleWithSAMLResponse = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryAssumeRoleWithWebIdentityResponse = (output, context) => {
-    const contents = {
+var deserializeAws_queryAssumeRoleWithWebIdentityResponse = function (output, context) {
+    var contents = {
         Credentials: undefined,
         SubjectFromWebIdentityToken: undefined,
         AssumedRoleUser: undefined,
@@ -801,8 +980,8 @@ const deserializeAws_queryAssumeRoleWithWebIdentityResponse = (output, context)
     }
     return contents;
 };
-const deserializeAws_queryCredentials = (output, context) => {
-    const contents = {
+var deserializeAws_queryCredentials = function (output, context) {
+    var contents = {
         AccessKeyId: undefined,
         SecretAccessKey: undefined,
         SessionToken: undefined,
@@ -822,8 +1001,8 @@ const deserializeAws_queryCredentials = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryDecodeAuthorizationMessageResponse = (output, context) => {
-    const contents = {
+var deserializeAws_queryDecodeAuthorizationMessageResponse = function (output, context) {
+    var contents = {
         DecodedMessage: undefined,
     };
     if (output["DecodedMessage"] !== undefined) {
@@ -831,8 +1010,8 @@ const deserializeAws_queryDecodeAuthorizationMessageResponse = (output, context)
     }
     return contents;
 };
-const deserializeAws_queryExpiredTokenException = (output, context) => {
-    const contents = {
+var deserializeAws_queryExpiredTokenException = function (output, context) {
+    var contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -840,8 +1019,8 @@ const deserializeAws_queryExpiredTokenException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryFederatedUser = (output, context) => {
-    const contents = {
+var deserializeAws_queryFederatedUser = function (output, context) {
+    var contents = {
         FederatedUserId: undefined,
         Arn: undefined,
     };
@@ -853,8 +1032,8 @@ const deserializeAws_queryFederatedUser = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryGetAccessKeyInfoResponse = (output, context) => {
-    const contents = {
+var deserializeAws_queryGetAccessKeyInfoResponse = function (output, context) {
+    var contents = {
         Account: undefined,
     };
     if (output["Account"] !== undefined) {
@@ -862,8 +1041,8 @@ const deserializeAws_queryGetAccessKeyInfoResponse = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryGetCallerIdentityResponse = (output, context) => {
-    const contents = {
+var deserializeAws_queryGetCallerIdentityResponse = function (output, context) {
+    var contents = {
         UserId: undefined,
         Account: undefined,
         Arn: undefined,
@@ -879,8 +1058,8 @@ const deserializeAws_queryGetCallerIdentityResponse = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryGetFederationTokenResponse = (output, context) => {
-    const contents = {
+var deserializeAws_queryGetFederationTokenResponse = function (output, context) {
+    var contents = {
         Credentials: undefined,
         FederatedUser: undefined,
         PackedPolicySize: undefined,
@@ -896,8 +1075,8 @@ const deserializeAws_queryGetFederationTokenResponse = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryGetSessionTokenResponse = (output, context) => {
-    const contents = {
+var deserializeAws_queryGetSessionTokenResponse = function (output, context) {
+    var contents = {
         Credentials: undefined,
     };
     if (output["Credentials"] !== undefined) {
@@ -905,8 +1084,8 @@ const deserializeAws_queryGetSessionTokenResponse = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryIDPCommunicationErrorException = (output, context) => {
-    const contents = {
+var deserializeAws_queryIDPCommunicationErrorException = function (output, context) {
+    var contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -914,8 +1093,8 @@ const deserializeAws_queryIDPCommunicationErrorException = (output, context) =>
     }
     return contents;
 };
-const deserializeAws_queryIDPRejectedClaimException = (output, context) => {
-    const contents = {
+var deserializeAws_queryIDPRejectedClaimException = function (output, context) {
+    var contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -923,8 +1102,8 @@ const deserializeAws_queryIDPRejectedClaimException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryInvalidAuthorizationMessageException = (output, context) => {
-    const contents = {
+var deserializeAws_queryInvalidAuthorizationMessageException = function (output, context) {
+    var contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -932,8 +1111,8 @@ const deserializeAws_queryInvalidAuthorizationMessageException = (output, contex
     }
     return contents;
 };
-const deserializeAws_queryInvalidIdentityTokenException = (output, context) => {
-    const contents = {
+var deserializeAws_queryInvalidIdentityTokenException = function (output, context) {
+    var contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -941,8 +1120,8 @@ const deserializeAws_queryInvalidIdentityTokenException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryMalformedPolicyDocumentException = (output, context) => {
-    const contents = {
+var deserializeAws_queryMalformedPolicyDocumentException = function (output, context) {
+    var contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -950,8 +1129,8 @@ const deserializeAws_queryMalformedPolicyDocumentException = (output, context) =
     }
     return contents;
 };
-const deserializeAws_queryPackedPolicyTooLargeException = (output, context) => {
-    const contents = {
+var deserializeAws_queryPackedPolicyTooLargeException = function (output, context) {
+    var contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -959,8 +1138,8 @@ const deserializeAws_queryPackedPolicyTooLargeException = (output, context) => {
     }
     return contents;
 };
-const deserializeAws_queryRegionDisabledException = (output, context) => {
-    const contents = {
+var deserializeAws_queryRegionDisabledException = function (output, context) {
+    var contents = {
         message: undefined,
     };
     if (output["message"] !== undefined) {
@@ -968,68 +1147,96 @@ const deserializeAws_queryRegionDisabledException = (output, context) => {
     }
     return contents;
 };
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const collectBody = (streamBody = new Uint8Array(), context) => {
+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(); }
     if (streamBody instanceof Uint8Array) {
         return Promise.resolve(streamBody);
     }
     return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
 };
-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);
-};
-const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
-    if (encoded.length) {
-        const parsedObj = xmlParse(encoded, {
-            attributeNamePrefix: "",
-            ignoreAttributes: false,
-            parseNodeValue: false,
-            trimValues: false,
-            tagValueProcessor: (val) => (val.trim() === "" && val.includes("\n") ? "" : decodeHTML(val)),
-        });
-        const textNodeName = "#text";
-        const key = Object.keys(parsedObj)[0];
-        const parsedObjToReturn = parsedObj[key];
-        if (parsedObjToReturn[textNodeName]) {
-            parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
-            delete parsedObjToReturn[textNodeName];
+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)];
         }
-        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;
+    });
+}); };
+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 buildFormUrlencodedString = (formEntries) => Object.entries(formEntries)
-    .map(([key, value]) => __extendedEncodeURIComponent(key) + "=" + __extendedEncodeURIComponent(value))
-    .join("&");
-const loadQueryErrorCode = (output, data) => {
+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];
+        }
+    });
+}); };
+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) {
     if (data.Error.Code !== undefined) {
         return data.Error.Code;
     }