@aws-sdk/client-elastic-load-balancing 3.31.0 → 3.35.0

package/{dist/es → dist-es}/protocols/Aws_query.js

@@ -10,7 +10,7 @@ export var serializeAws_queryAddTagsCommand = function (input, context) { return
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryAddTagsInput(input, context)), { Action: "AddTags", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryApplySecurityGroupsToLoadBalancerCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -20,7 +20,7 @@ export var serializeAws_queryApplySecurityGroupsToLoadBalancerCommand = function
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryApplySecurityGroupsToLoadBalancerInput(input, context)), { Action: "ApplySecurityGroupsToLoadBalancer", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryAttachLoadBalancerToSubnetsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -30,7 +30,7 @@ export var serializeAws_queryAttachLoadBalancerToSubnetsCommand = function (inpu
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryAttachLoadBalancerToSubnetsInput(input, context)), { Action: "AttachLoadBalancerToSubnets", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryConfigureHealthCheckCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -40,7 +40,7 @@ export var serializeAws_queryConfigureHealthCheckCommand = function (input, cont
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryConfigureHealthCheckInput(input, context)), { Action: "ConfigureHealthCheck", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryCreateAppCookieStickinessPolicyCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -50,7 +50,7 @@ export var serializeAws_queryCreateAppCookieStickinessPolicyCommand = function (
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryCreateAppCookieStickinessPolicyInput(input, context)), { Action: "CreateAppCookieStickinessPolicy", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryCreateLBCookieStickinessPolicyCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -60,7 +60,7 @@ export var serializeAws_queryCreateLBCookieStickinessPolicyCommand = function (i
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryCreateLBCookieStickinessPolicyInput(input, context)), { Action: "CreateLBCookieStickinessPolicy", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryCreateLoadBalancerCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -70,7 +70,7 @@ export var serializeAws_queryCreateLoadBalancerCommand = function (input, contex
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryCreateAccessPointInput(input, context)), { Action: "CreateLoadBalancer", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryCreateLoadBalancerListenersCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -80,7 +80,7 @@ export var serializeAws_queryCreateLoadBalancerListenersCommand = function (inpu
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryCreateLoadBalancerListenerInput(input, context)), { Action: "CreateLoadBalancerListeners", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryCreateLoadBalancerPolicyCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -90,7 +90,7 @@ export var serializeAws_queryCreateLoadBalancerPolicyCommand = function (input,
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryCreateLoadBalancerPolicyInput(input, context)), { Action: "CreateLoadBalancerPolicy", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDeleteLoadBalancerCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -100,7 +100,7 @@ export var serializeAws_queryDeleteLoadBalancerCommand = function (input, contex
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDeleteAccessPointInput(input, context)), { Action: "DeleteLoadBalancer", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDeleteLoadBalancerListenersCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -110,7 +110,7 @@ export var serializeAws_queryDeleteLoadBalancerListenersCommand = function (inpu
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDeleteLoadBalancerListenerInput(input, context)), { Action: "DeleteLoadBalancerListeners", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDeleteLoadBalancerPolicyCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -120,7 +120,7 @@ export var serializeAws_queryDeleteLoadBalancerPolicyCommand = function (input,
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDeleteLoadBalancerPolicyInput(input, context)), { Action: "DeleteLoadBalancerPolicy", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDeregisterInstancesFromLoadBalancerCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -130,7 +130,7 @@ export var serializeAws_queryDeregisterInstancesFromLoadBalancerCommand = functi
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDeregisterEndPointsInput(input, context)), { Action: "DeregisterInstancesFromLoadBalancer", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDescribeAccountLimitsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -140,7 +140,7 @@ export var serializeAws_queryDescribeAccountLimitsCommand = function (input, con
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDescribeAccountLimitsInput(input, context)), { Action: "DescribeAccountLimits", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDescribeInstanceHealthCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -150,7 +150,7 @@ export var serializeAws_queryDescribeInstanceHealthCommand = function (input, co
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDescribeEndPointStateInput(input, context)), { Action: "DescribeInstanceHealth", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDescribeLoadBalancerAttributesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -160,7 +160,7 @@ export var serializeAws_queryDescribeLoadBalancerAttributesCommand = function (i
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDescribeLoadBalancerAttributesInput(input, context)), { Action: "DescribeLoadBalancerAttributes", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDescribeLoadBalancerPoliciesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -170,7 +170,7 @@ export var serializeAws_queryDescribeLoadBalancerPoliciesCommand = function (inp
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDescribeLoadBalancerPoliciesInput(input, context)), { Action: "DescribeLoadBalancerPolicies", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDescribeLoadBalancerPolicyTypesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -180,7 +180,7 @@ export var serializeAws_queryDescribeLoadBalancerPolicyTypesCommand = function (
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDescribeLoadBalancerPolicyTypesInput(input, context)), { Action: "DescribeLoadBalancerPolicyTypes", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDescribeLoadBalancersCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -190,7 +190,7 @@ export var serializeAws_queryDescribeLoadBalancersCommand = function (input, con
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDescribeAccessPointsInput(input, context)), { Action: "DescribeLoadBalancers", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDescribeTagsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -200,7 +200,7 @@ export var serializeAws_queryDescribeTagsCommand = function (input, context) { r
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDescribeTagsInput(input, context)), { Action: "DescribeTags", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDetachLoadBalancerFromSubnetsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -210,7 +210,7 @@ export var serializeAws_queryDetachLoadBalancerFromSubnetsCommand = function (in
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDetachLoadBalancerFromSubnetsInput(input, context)), { Action: "DetachLoadBalancerFromSubnets", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -220,7 +220,7 @@ export var serializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand = fu
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryRemoveAvailabilityZonesInput(input, context)), { Action: "DisableAvailabilityZonesForLoadBalancer", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -230,7 +230,7 @@ export var serializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = fun
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryAddAvailabilityZonesInput(input, context)), { Action: "EnableAvailabilityZonesForLoadBalancer", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryModifyLoadBalancerAttributesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -240,7 +240,7 @@ export var serializeAws_queryModifyLoadBalancerAttributesCommand = function (inp
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryModifyLoadBalancerAttributesInput(input, context)), { Action: "ModifyLoadBalancerAttributes", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryRegisterInstancesWithLoadBalancerCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -250,7 +250,7 @@ export var serializeAws_queryRegisterInstancesWithLoadBalancerCommand = function
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryRegisterEndPointsInput(input, context)), { Action: "RegisterInstancesWithLoadBalancer", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_queryRemoveTagsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -260,7 +260,7 @@ export var serializeAws_queryRemoveTagsCommand = function (input, context) { ret
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryRemoveTagsInput(input, context)), { Action: "RemoveTags", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_querySetLoadBalancerListenerSSLCertificateCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -270,7 +270,7 @@ export var serializeAws_querySetLoadBalancerListenerSSLCertificateCommand = func
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_querySetLoadBalancerListenerSSLCertificateInput(input, context)), { Action: "SetLoadBalancerListenerSSLCertificate", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -280,7 +280,7 @@ export var serializeAws_querySetLoadBalancerPoliciesForBackendServerCommand = fu
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_querySetLoadBalancerPoliciesForBackendServerInput(input, context)), { Action: "SetLoadBalancerPoliciesForBackendServer", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var serializeAws_querySetLoadBalancerPoliciesOfListenerCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -290,7 +290,7 @@ export var serializeAws_querySetLoadBalancerPoliciesOfListenerCommand = function
             "content-type": "application/x-www-form-urlencoded",
         };
         body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_querySetLoadBalancerPoliciesOfListenerInput(input, context)), { Action: "SetLoadBalancerPoliciesOfListener", Version: "2012-06-01" }));
-        return [2 /*return*/, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
 export var deserializeAws_queryAddTagsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -299,15 +299,15 @@ export var deserializeAws_queryAddTagsCommand = function (output, context) { ret
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryAddTagsCommandError(output, context)];
+                    return [2, deserializeAws_queryAddTagsCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryAddTagsOutput(data.AddTagsResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -319,39 +319,39 @@ var deserializeAws_queryAddTagsCommandError = function (output, context) { retur
             case 0:
                 _a = [__assign({}, output)];
                 _f = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "DuplicateTagKeysException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException": return [3 /*break*/, 4];
-                    case "TooManyTagsException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#TooManyTagsException": return [3 /*break*/, 6];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "DuplicateTagKeysException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException": return [3, 4];
+                    case "TooManyTagsException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#TooManyTagsException": return [3, 6];
                 }
-                return [3 /*break*/, 8];
+                return [3, 8];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 8:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -361,7 +361,7 @@ var deserializeAws_queryAddTagsCommandError = function (output, context) { retur
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -371,15 +371,15 @@ export var deserializeAws_queryApplySecurityGroupsToLoadBalancerCommand = functi
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError(output, context)];
+                    return [2, deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryApplySecurityGroupsToLoadBalancerOutput(data.ApplySecurityGroupsToLoadBalancerResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -391,39 +391,39 @@ var deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = function
             case 0:
                 _a = [__assign({}, output)];
                 _f = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "InvalidSecurityGroupException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException": return [3 /*break*/, 6];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidConfigurationRequestException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
+                    case "InvalidSecurityGroupException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException": return [3, 6];
                 }
-                return [3 /*break*/, 8];
+                return [3, 8];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 8:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -433,7 +433,7 @@ var deserializeAws_queryApplySecurityGroupsToLoadBalancerCommandError = function
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -443,15 +443,15 @@ export var deserializeAws_queryAttachLoadBalancerToSubnetsCommand = function (ou
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryAttachLoadBalancerToSubnetsCommandError(output, context)];
+                    return [2, deserializeAws_queryAttachLoadBalancerToSubnetsCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryAttachLoadBalancerToSubnetsOutput(data.AttachLoadBalancerToSubnetsResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -463,47 +463,47 @@ var deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = function (outp
             case 0:
                 _a = [__assign({}, output)];
                 _g = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "InvalidSubnetException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#InvalidSubnetException": return [3 /*break*/, 6];
-                    case "SubnetNotFoundException": return [3 /*break*/, 8];
-                    case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException": return [3 /*break*/, 8];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidConfigurationRequestException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
+                    case "InvalidSubnetException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#InvalidSubnetException": return [3, 6];
+                    case "SubnetNotFoundException": return [3, 8];
+                    case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException": return [3, 8];
                 }
-                return [3 /*break*/, 10];
+                return [3, 10];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 8:
                 _f = [{}];
-                return [4 /*yield*/, deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context)];
             case 9:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 10:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -513,7 +513,7 @@ var deserializeAws_queryAttachLoadBalancerToSubnetsCommandError = function (outp
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -523,15 +523,15 @@ export var deserializeAws_queryConfigureHealthCheckCommand = function (output, c
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryConfigureHealthCheckCommandError(output, context)];
+                    return [2, deserializeAws_queryConfigureHealthCheckCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryConfigureHealthCheckOutput(data.ConfigureHealthCheckResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -543,23 +543,23 @@ var deserializeAws_queryConfigureHealthCheckCommandError = function (output, con
             case 0:
                 _a = [__assign({}, output)];
                 _d = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
                 }
-                return [3 /*break*/, 4];
+                return [3, 4];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 5];
+                return [3, 5];
             case 4:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -569,7 +569,7 @@ var deserializeAws_queryConfigureHealthCheckCommandError = function (output, con
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -579,15 +579,15 @@ export var deserializeAws_queryCreateAppCookieStickinessPolicyCommand = function
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryCreateAppCookieStickinessPolicyCommandError(output, context)];
+                    return [2, deserializeAws_queryCreateAppCookieStickinessPolicyCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryCreateAppCookieStickinessPolicyOutput(data.CreateAppCookieStickinessPolicyResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -599,47 +599,47 @@ var deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = function (
             case 0:
                 _a = [__assign({}, output)];
                 _g = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "DuplicatePolicyNameException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException": return [3 /*break*/, 4];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 6];
-                    case "TooManyPoliciesException": return [3 /*break*/, 8];
-                    case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException": return [3 /*break*/, 8];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "DuplicatePolicyNameException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException": return [3, 4];
+                    case "InvalidConfigurationRequestException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 6];
+                    case "TooManyPoliciesException": return [3, 8];
+                    case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException": return [3, 8];
                 }
-                return [3 /*break*/, 10];
+                return [3, 10];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 8:
                 _f = [{}];
-                return [4 /*yield*/, deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)];
             case 9:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 10:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -649,7 +649,7 @@ var deserializeAws_queryCreateAppCookieStickinessPolicyCommandError = function (
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -659,15 +659,15 @@ export var deserializeAws_queryCreateLBCookieStickinessPolicyCommand = function
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryCreateLBCookieStickinessPolicyCommandError(output, context)];
+                    return [2, deserializeAws_queryCreateLBCookieStickinessPolicyCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryCreateLBCookieStickinessPolicyOutput(data.CreateLBCookieStickinessPolicyResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -679,47 +679,47 @@ var deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = function (o
             case 0:
                 _a = [__assign({}, output)];
                 _g = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "DuplicatePolicyNameException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException": return [3 /*break*/, 4];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 6];
-                    case "TooManyPoliciesException": return [3 /*break*/, 8];
-                    case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException": return [3 /*break*/, 8];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "DuplicatePolicyNameException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException": return [3, 4];
+                    case "InvalidConfigurationRequestException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 6];
+                    case "TooManyPoliciesException": return [3, 8];
+                    case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException": return [3, 8];
                 }
-                return [3 /*break*/, 10];
+                return [3, 10];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 8:
                 _f = [{}];
-                return [4 /*yield*/, deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)];
             case 9:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 10:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -729,7 +729,7 @@ var deserializeAws_queryCreateLBCookieStickinessPolicyCommandError = function (o
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -739,15 +739,15 @@ export var deserializeAws_queryCreateLoadBalancerCommand = function (output, con
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryCreateLoadBalancerCommandError(output, context)];
+                    return [2, deserializeAws_queryCreateLoadBalancerCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryCreateAccessPointOutput(data.CreateLoadBalancerResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -759,111 +759,111 @@ var deserializeAws_queryCreateLoadBalancerCommandError = function (output, conte
             case 0:
                 _a = [__assign({}, output)];
                 _q = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_q.body = _r.sent(), _q)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "CertificateNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException": return [3 /*break*/, 2];
-                    case "DuplicateAccessPointNameException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#DuplicateAccessPointNameException": return [3 /*break*/, 4];
-                    case "DuplicateTagKeysException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException": return [3 /*break*/, 6];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 8];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 8];
-                    case "InvalidSchemeException": return [3 /*break*/, 10];
-                    case "com.amazonaws.elasticloadbalancing#InvalidSchemeException": return [3 /*break*/, 10];
-                    case "InvalidSecurityGroupException": return [3 /*break*/, 12];
-                    case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException": return [3 /*break*/, 12];
-                    case "InvalidSubnetException": return [3 /*break*/, 14];
-                    case "com.amazonaws.elasticloadbalancing#InvalidSubnetException": return [3 /*break*/, 14];
-                    case "OperationNotPermittedException": return [3 /*break*/, 16];
-                    case "com.amazonaws.elasticloadbalancing#OperationNotPermittedException": return [3 /*break*/, 16];
-                    case "SubnetNotFoundException": return [3 /*break*/, 18];
-                    case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException": return [3 /*break*/, 18];
-                    case "TooManyAccessPointsException": return [3 /*break*/, 20];
-                    case "com.amazonaws.elasticloadbalancing#TooManyAccessPointsException": return [3 /*break*/, 20];
-                    case "TooManyTagsException": return [3 /*break*/, 22];
-                    case "com.amazonaws.elasticloadbalancing#TooManyTagsException": return [3 /*break*/, 22];
-                    case "UnsupportedProtocolException": return [3 /*break*/, 24];
-                    case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException": return [3 /*break*/, 24];
+                    case "CertificateNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException": return [3, 2];
+                    case "DuplicateAccessPointNameException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#DuplicateAccessPointNameException": return [3, 4];
+                    case "DuplicateTagKeysException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException": return [3, 6];
+                    case "InvalidConfigurationRequestException": return [3, 8];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 8];
+                    case "InvalidSchemeException": return [3, 10];
+                    case "com.amazonaws.elasticloadbalancing#InvalidSchemeException": return [3, 10];
+                    case "InvalidSecurityGroupException": return [3, 12];
+                    case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException": return [3, 12];
+                    case "InvalidSubnetException": return [3, 14];
+                    case "com.amazonaws.elasticloadbalancing#InvalidSubnetException": return [3, 14];
+                    case "OperationNotPermittedException": return [3, 16];
+                    case "com.amazonaws.elasticloadbalancing#OperationNotPermittedException": return [3, 16];
+                    case "SubnetNotFoundException": return [3, 18];
+                    case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException": return [3, 18];
+                    case "TooManyAccessPointsException": return [3, 20];
+                    case "com.amazonaws.elasticloadbalancing#TooManyAccessPointsException": return [3, 20];
+                    case "TooManyTagsException": return [3, 22];
+                    case "com.amazonaws.elasticloadbalancing#TooManyTagsException": return [3, 22];
+                    case "UnsupportedProtocolException": return [3, 24];
+                    case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException": return [3, 24];
                 }
-                return [3 /*break*/, 26];
+                return [3, 26];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryDuplicateAccessPointNameExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryDuplicateAccessPointNameExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryDuplicateTagKeysExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 8:
                 _f = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 9:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 10:
                 _g = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidSchemeExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidSchemeExceptionResponse(parsedOutput, context)];
             case 11:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 12:
                 _h = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidSecurityGroupExceptionResponse(parsedOutput, context)];
             case 13:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _h.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 14:
                 _j = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidSubnetExceptionResponse(parsedOutput, context)];
             case 15:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _j.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 16:
                 _k = [{}];
-                return [4 /*yield*/, deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryOperationNotPermittedExceptionResponse(parsedOutput, context)];
             case 17:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _k.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 18:
                 _l = [{}];
-                return [4 /*yield*/, deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_querySubnetNotFoundExceptionResponse(parsedOutput, context)];
             case 19:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _l.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 20:
                 _m = [{}];
-                return [4 /*yield*/, deserializeAws_queryTooManyAccessPointsExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryTooManyAccessPointsExceptionResponse(parsedOutput, context)];
             case 21:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _m.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 22:
                 _o = [{}];
-                return [4 /*yield*/, deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)];
             case 23:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _o.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 24:
                 _p = [{}];
-                return [4 /*yield*/, deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)];
             case 25:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _p.concat([(_r.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 27];
+                return [3, 27];
             case 26:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -873,7 +873,7 @@ var deserializeAws_queryCreateLoadBalancerCommandError = function (output, conte
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -883,15 +883,15 @@ export var deserializeAws_queryCreateLoadBalancerListenersCommand = function (ou
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryCreateLoadBalancerListenersCommandError(output, context)];
+                    return [2, deserializeAws_queryCreateLoadBalancerListenersCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryCreateLoadBalancerListenerOutput(data.CreateLoadBalancerListenersResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -903,55 +903,55 @@ var deserializeAws_queryCreateLoadBalancerListenersCommandError = function (outp
             case 0:
                 _a = [__assign({}, output)];
                 _h = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_h.body = _j.sent(), _h)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "CertificateNotFoundException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException": return [3 /*break*/, 4];
-                    case "DuplicateListenerException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#DuplicateListenerException": return [3 /*break*/, 6];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 8];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 8];
-                    case "UnsupportedProtocolException": return [3 /*break*/, 10];
-                    case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException": return [3 /*break*/, 10];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "CertificateNotFoundException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException": return [3, 4];
+                    case "DuplicateListenerException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#DuplicateListenerException": return [3, 6];
+                    case "InvalidConfigurationRequestException": return [3, 8];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 8];
+                    case "UnsupportedProtocolException": return [3, 10];
+                    case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException": return [3, 10];
                 }
-                return [3 /*break*/, 12];
+                return [3, 12];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryDuplicateListenerExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 8:
                 _f = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 9:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 10:
                 _g = [{}];
-                return [4 /*yield*/, deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)];
             case 11:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 12:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -961,7 +961,7 @@ var deserializeAws_queryCreateLoadBalancerListenersCommandError = function (outp
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -971,15 +971,15 @@ export var deserializeAws_queryCreateLoadBalancerPolicyCommand = function (outpu
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryCreateLoadBalancerPolicyCommandError(output, context)];
+                    return [2, deserializeAws_queryCreateLoadBalancerPolicyCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryCreateLoadBalancerPolicyOutput(data.CreateLoadBalancerPolicyResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -991,55 +991,55 @@ var deserializeAws_queryCreateLoadBalancerPolicyCommandError = function (output,
             case 0:
                 _a = [__assign({}, output)];
                 _h = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_h.body = _j.sent(), _h)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "DuplicatePolicyNameException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException": return [3 /*break*/, 4];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 6];
-                    case "PolicyTypeNotFoundException": return [3 /*break*/, 8];
-                    case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException": return [3 /*break*/, 8];
-                    case "TooManyPoliciesException": return [3 /*break*/, 10];
-                    case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException": return [3 /*break*/, 10];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "DuplicatePolicyNameException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException": return [3, 4];
+                    case "InvalidConfigurationRequestException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 6];
+                    case "PolicyTypeNotFoundException": return [3, 8];
+                    case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException": return [3, 8];
+                    case "TooManyPoliciesException": return [3, 10];
+                    case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException": return [3, 10];
                 }
-                return [3 /*break*/, 12];
+                return [3, 12];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryDuplicatePolicyNameExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 8:
                 _f = [{}];
-                return [4 /*yield*/, deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context)];
             case 9:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 10:
                 _g = [{}];
-                return [4 /*yield*/, deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryTooManyPoliciesExceptionResponse(parsedOutput, context)];
             case 11:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 12:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1049,7 +1049,7 @@ var deserializeAws_queryCreateLoadBalancerPolicyCommandError = function (output,
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1059,15 +1059,15 @@ export var deserializeAws_queryDeleteLoadBalancerCommand = function (output, con
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDeleteLoadBalancerCommandError(output, context)];
+                    return [2, deserializeAws_queryDeleteLoadBalancerCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDeleteAccessPointOutput(data.DeleteLoadBalancerResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1079,7 +1079,7 @@ var deserializeAws_queryDeleteLoadBalancerCommandError = function (output, conte
             case 0:
                 _a = [__assign({}, output)];
                 _b = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
                 errorCode = "UnknownError";
@@ -1093,7 +1093,7 @@ var deserializeAws_queryDeleteLoadBalancerCommandError = function (output, conte
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1103,15 +1103,15 @@ export var deserializeAws_queryDeleteLoadBalancerListenersCommand = function (ou
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDeleteLoadBalancerListenersCommandError(output, context)];
+                    return [2, deserializeAws_queryDeleteLoadBalancerListenersCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDeleteLoadBalancerListenerOutput(data.DeleteLoadBalancerListenersResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1123,23 +1123,23 @@ var deserializeAws_queryDeleteLoadBalancerListenersCommandError = function (outp
             case 0:
                 _a = [__assign({}, output)];
                 _d = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
                 }
-                return [3 /*break*/, 4];
+                return [3, 4];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 5];
+                return [3, 5];
             case 4:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1149,7 +1149,7 @@ var deserializeAws_queryDeleteLoadBalancerListenersCommandError = function (outp
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1159,15 +1159,15 @@ export var deserializeAws_queryDeleteLoadBalancerPolicyCommand = function (outpu
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDeleteLoadBalancerPolicyCommandError(output, context)];
+                    return [2, deserializeAws_queryDeleteLoadBalancerPolicyCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDeleteLoadBalancerPolicyOutput(data.DeleteLoadBalancerPolicyResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1179,31 +1179,31 @@ var deserializeAws_queryDeleteLoadBalancerPolicyCommandError = function (output,
             case 0:
                 _a = [__assign({}, output)];
                 _e = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 4];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidConfigurationRequestException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
                 }
-                return [3 /*break*/, 6];
+                return [3, 6];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 6:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1213,7 +1213,7 @@ var deserializeAws_queryDeleteLoadBalancerPolicyCommandError = function (output,
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1223,15 +1223,15 @@ export var deserializeAws_queryDeregisterInstancesFromLoadBalancerCommand = func
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError(output, context)];
+                    return [2, deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDeregisterEndPointsOutput(data.DeregisterInstancesFromLoadBalancerResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1243,31 +1243,31 @@ var deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = functi
             case 0:
                 _a = [__assign({}, output)];
                 _e = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidEndPointException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidEndPointException": return [3 /*break*/, 4];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidEndPointException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidEndPointException": return [3, 4];
                 }
-                return [3 /*break*/, 6];
+                return [3, 6];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 6:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1277,7 +1277,7 @@ var deserializeAws_queryDeregisterInstancesFromLoadBalancerCommandError = functi
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1287,15 +1287,15 @@ export var deserializeAws_queryDescribeAccountLimitsCommand = function (output,
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDescribeAccountLimitsCommandError(output, context)];
+                    return [2, deserializeAws_queryDescribeAccountLimitsCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDescribeAccountLimitsOutput(data.DescribeAccountLimitsResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1307,7 +1307,7 @@ var deserializeAws_queryDescribeAccountLimitsCommandError = function (output, co
             case 0:
                 _a = [__assign({}, output)];
                 _b = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
                 errorCode = "UnknownError";
@@ -1321,7 +1321,7 @@ var deserializeAws_queryDescribeAccountLimitsCommandError = function (output, co
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1331,15 +1331,15 @@ export var deserializeAws_queryDescribeInstanceHealthCommand = function (output,
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDescribeInstanceHealthCommandError(output, context)];
+                    return [2, deserializeAws_queryDescribeInstanceHealthCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDescribeEndPointStateOutput(data.DescribeInstanceHealthResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1351,31 +1351,31 @@ var deserializeAws_queryDescribeInstanceHealthCommandError = function (output, c
             case 0:
                 _a = [__assign({}, output)];
                 _e = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidEndPointException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidEndPointException": return [3 /*break*/, 4];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidEndPointException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidEndPointException": return [3, 4];
                 }
-                return [3 /*break*/, 6];
+                return [3, 6];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 6:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1385,7 +1385,7 @@ var deserializeAws_queryDescribeInstanceHealthCommandError = function (output, c
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1395,15 +1395,15 @@ export var deserializeAws_queryDescribeLoadBalancerAttributesCommand = function
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDescribeLoadBalancerAttributesCommandError(output, context)];
+                    return [2, deserializeAws_queryDescribeLoadBalancerAttributesCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDescribeLoadBalancerAttributesOutput(data.DescribeLoadBalancerAttributesResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1415,31 +1415,31 @@ var deserializeAws_queryDescribeLoadBalancerAttributesCommandError = function (o
             case 0:
                 _a = [__assign({}, output)];
                 _e = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "LoadBalancerAttributeNotFoundException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException": return [3 /*break*/, 4];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "LoadBalancerAttributeNotFoundException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException": return [3, 4];
                 }
-                return [3 /*break*/, 6];
+                return [3, 6];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 6:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1449,7 +1449,7 @@ var deserializeAws_queryDescribeLoadBalancerAttributesCommandError = function (o
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1459,15 +1459,15 @@ export var deserializeAws_queryDescribeLoadBalancerPoliciesCommand = function (o
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDescribeLoadBalancerPoliciesCommandError(output, context)];
+                    return [2, deserializeAws_queryDescribeLoadBalancerPoliciesCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDescribeLoadBalancerPoliciesOutput(data.DescribeLoadBalancerPoliciesResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1479,31 +1479,31 @@ var deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = function (out
             case 0:
                 _a = [__assign({}, output)];
                 _e = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "PolicyNotFoundException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException": return [3 /*break*/, 4];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "PolicyNotFoundException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException": return [3, 4];
                 }
-                return [3 /*break*/, 6];
+                return [3, 6];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 6:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1513,7 +1513,7 @@ var deserializeAws_queryDescribeLoadBalancerPoliciesCommandError = function (out
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1523,15 +1523,15 @@ export var deserializeAws_queryDescribeLoadBalancerPolicyTypesCommand = function
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError(output, context)];
+                    return [2, deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDescribeLoadBalancerPolicyTypesOutput(data.DescribeLoadBalancerPolicyTypesResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1543,23 +1543,23 @@ var deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = function (
             case 0:
                 _a = [__assign({}, output)];
                 _d = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "PolicyTypeNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException": return [3 /*break*/, 2];
+                    case "PolicyTypeNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException": return [3, 2];
                 }
-                return [3 /*break*/, 4];
+                return [3, 4];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryPolicyTypeNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 5];
+                return [3, 5];
             case 4:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1569,7 +1569,7 @@ var deserializeAws_queryDescribeLoadBalancerPolicyTypesCommandError = function (
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1579,15 +1579,15 @@ export var deserializeAws_queryDescribeLoadBalancersCommand = function (output,
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDescribeLoadBalancersCommandError(output, context)];
+                    return [2, deserializeAws_queryDescribeLoadBalancersCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDescribeAccessPointsOutput(data.DescribeLoadBalancersResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1599,31 +1599,31 @@ var deserializeAws_queryDescribeLoadBalancersCommandError = function (output, co
             case 0:
                 _a = [__assign({}, output)];
                 _e = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "DependencyThrottleException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#DependencyThrottleException": return [3 /*break*/, 4];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "DependencyThrottleException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#DependencyThrottleException": return [3, 4];
                 }
-                return [3 /*break*/, 6];
+                return [3, 6];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryDependencyThrottleExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryDependencyThrottleExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 6:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1633,7 +1633,7 @@ var deserializeAws_queryDescribeLoadBalancersCommandError = function (output, co
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1643,15 +1643,15 @@ export var deserializeAws_queryDescribeTagsCommand = function (output, context)
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDescribeTagsCommandError(output, context)];
+                    return [2, deserializeAws_queryDescribeTagsCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDescribeTagsOutput(data.DescribeTagsResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1663,23 +1663,23 @@ var deserializeAws_queryDescribeTagsCommandError = function (output, context) {
             case 0:
                 _a = [__assign({}, output)];
                 _d = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
                 }
-                return [3 /*break*/, 4];
+                return [3, 4];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 5];
+                return [3, 5];
             case 4:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1689,7 +1689,7 @@ var deserializeAws_queryDescribeTagsCommandError = function (output, context) {
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1699,15 +1699,15 @@ export var deserializeAws_queryDetachLoadBalancerFromSubnetsCommand = function (
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError(output, context)];
+                    return [2, deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryDetachLoadBalancerFromSubnetsOutput(data.DetachLoadBalancerFromSubnetsResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1719,31 +1719,31 @@ var deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = function (ou
             case 0:
                 _a = [__assign({}, output)];
                 _e = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 4];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidConfigurationRequestException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
                 }
-                return [3 /*break*/, 6];
+                return [3, 6];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 6:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1753,7 +1753,7 @@ var deserializeAws_queryDetachLoadBalancerFromSubnetsCommandError = function (ou
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1763,15 +1763,15 @@ export var deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommand =
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError(output, context)];
+                    return [2, deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryRemoveAvailabilityZonesOutput(data.DisableAvailabilityZonesForLoadBalancerResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1783,31 +1783,31 @@ var deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError = fu
             case 0:
                 _a = [__assign({}, output)];
                 _e = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 4];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidConfigurationRequestException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
                 }
-                return [3 /*break*/, 6];
+                return [3, 6];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 6:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1817,7 +1817,7 @@ var deserializeAws_queryDisableAvailabilityZonesForLoadBalancerCommandError = fu
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1827,15 +1827,15 @@ export var deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommand = f
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError(output, context)];
+                    return [2, deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryAddAvailabilityZonesOutput(data.EnableAvailabilityZonesForLoadBalancerResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1847,23 +1847,23 @@ var deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = fun
             case 0:
                 _a = [__assign({}, output)];
                 _d = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
                 }
-                return [3 /*break*/, 4];
+                return [3, 4];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 5];
+                return [3, 5];
             case 4:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1873,7 +1873,7 @@ var deserializeAws_queryEnableAvailabilityZonesForLoadBalancerCommandError = fun
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1883,15 +1883,15 @@ export var deserializeAws_queryModifyLoadBalancerAttributesCommand = function (o
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryModifyLoadBalancerAttributesCommandError(output, context)];
+                    return [2, deserializeAws_queryModifyLoadBalancerAttributesCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryModifyLoadBalancerAttributesOutput(data.ModifyLoadBalancerAttributesResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1903,39 +1903,39 @@ var deserializeAws_queryModifyLoadBalancerAttributesCommandError = function (out
             case 0:
                 _a = [__assign({}, output)];
                 _f = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "LoadBalancerAttributeNotFoundException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException": return [3 /*break*/, 6];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidConfigurationRequestException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
+                    case "LoadBalancerAttributeNotFoundException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException": return [3, 6];
                 }
-                return [3 /*break*/, 8];
+                return [3, 8];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 8:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -1945,7 +1945,7 @@ var deserializeAws_queryModifyLoadBalancerAttributesCommandError = function (out
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -1955,15 +1955,15 @@ export var deserializeAws_queryRegisterInstancesWithLoadBalancerCommand = functi
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError(output, context)];
+                    return [2, deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryRegisterEndPointsOutput(data.RegisterInstancesWithLoadBalancerResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -1975,31 +1975,31 @@ var deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = function
             case 0:
                 _a = [__assign({}, output)];
                 _e = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_e.body = _f.sent(), _e)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidEndPointException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidEndPointException": return [3 /*break*/, 4];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidEndPointException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidEndPointException": return [3, 4];
                 }
-                return [3 /*break*/, 6];
+                return [3, 6];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidEndPointExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_f.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 7];
+                return [3, 7];
             case 6:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -2009,7 +2009,7 @@ var deserializeAws_queryRegisterInstancesWithLoadBalancerCommandError = function
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -2019,15 +2019,15 @@ export var deserializeAws_queryRemoveTagsCommand = function (output, context) {
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_queryRemoveTagsCommandError(output, context)];
+                    return [2, deserializeAws_queryRemoveTagsCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_queryRemoveTagsOutput(data.RemoveTagsResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -2039,23 +2039,23 @@ var deserializeAws_queryRemoveTagsCommandError = function (output, context) { re
             case 0:
                 _a = [__assign({}, output)];
                 _d = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
                 }
-                return [3 /*break*/, 4];
+                return [3, 4];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 5];
+                return [3, 5];
             case 4:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -2065,7 +2065,7 @@ var deserializeAws_queryRemoveTagsCommandError = function (output, context) { re
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -2075,15 +2075,15 @@ export var deserializeAws_querySetLoadBalancerListenerSSLCertificateCommand = fu
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError(output, context)];
+                    return [2, deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_querySetLoadBalancerListenerSSLCertificateOutput(data.SetLoadBalancerListenerSSLCertificateResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -2095,55 +2095,55 @@ var deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = func
             case 0:
                 _a = [__assign({}, output)];
                 _h = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_h.body = _j.sent(), _h)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "CertificateNotFoundException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException": return [3 /*break*/, 4];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 6];
-                    case "ListenerNotFoundException": return [3 /*break*/, 8];
-                    case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException": return [3 /*break*/, 8];
-                    case "UnsupportedProtocolException": return [3 /*break*/, 10];
-                    case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException": return [3 /*break*/, 10];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "CertificateNotFoundException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException": return [3, 4];
+                    case "InvalidConfigurationRequestException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 6];
+                    case "ListenerNotFoundException": return [3, 8];
+                    case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException": return [3, 8];
+                    case "UnsupportedProtocolException": return [3, 10];
+                    case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException": return [3, 10];
                 }
-                return [3 /*break*/, 12];
+                return [3, 12];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryCertificateNotFoundExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 8:
                 _f = [{}];
-                return [4 /*yield*/, deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)];
             case 9:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 10:
                 _g = [{}];
-                return [4 /*yield*/, deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryUnsupportedProtocolExceptionResponse(parsedOutput, context)];
             case 11:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _g.concat([(_j.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 13];
+                return [3, 13];
             case 12:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -2153,7 +2153,7 @@ var deserializeAws_querySetLoadBalancerListenerSSLCertificateCommandError = func
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -2163,15 +2163,15 @@ export var deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommand =
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError(output, context)];
+                    return [2, deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_querySetLoadBalancerPoliciesForBackendServerOutput(data.SetLoadBalancerPoliciesForBackendServerResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -2183,39 +2183,39 @@ var deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError = fu
             case 0:
                 _a = [__assign({}, output)];
                 _f = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_f.body = _g.sent(), _f)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "PolicyNotFoundException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException": return [3 /*break*/, 6];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidConfigurationRequestException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
+                    case "PolicyNotFoundException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException": return [3, 6];
                 }
-                return [3 /*break*/, 8];
+                return [3, 8];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_g.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 8:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -2225,7 +2225,7 @@ var deserializeAws_querySetLoadBalancerPoliciesForBackendServerCommandError = fu
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -2235,15 +2235,15 @@ export var deserializeAws_querySetLoadBalancerPoliciesOfListenerCommand = functi
         switch (_a.label) {
             case 0:
                 if (output.statusCode >= 300) {
-                    return [2 /*return*/, deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError(output, context)];
+                    return [2, deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError(output, context)];
                 }
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
                 contents = {};
                 contents = deserializeAws_querySetLoadBalancerPoliciesOfListenerOutput(data.SetLoadBalancerPoliciesOfListenerResult, context);
                 response = __assign({ $metadata: deserializeMetadata(output) }, contents);
-                return [2 /*return*/, Promise.resolve(response)];
+                return [2, Promise.resolve(response)];
         }
     });
 }); };
@@ -2255,47 +2255,47 @@ var deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError = function
             case 0:
                 _a = [__assign({}, output)];
                 _g = {};
-                return [4 /*yield*/, parseBody(output.body, context)];
+                return [4, parseBody(output.body, context)];
             case 1:
                 parsedOutput = __assign.apply(void 0, _a.concat([(_g.body = _h.sent(), _g)]));
                 errorCode = "UnknownError";
                 errorCode = loadQueryErrorCode(output, parsedOutput.body);
                 _b = errorCode;
                 switch (_b) {
-                    case "AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3 /*break*/, 2];
-                    case "InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3 /*break*/, 4];
-                    case "ListenerNotFoundException": return [3 /*break*/, 6];
-                    case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException": return [3 /*break*/, 6];
-                    case "PolicyNotFoundException": return [3 /*break*/, 8];
-                    case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException": return [3 /*break*/, 8];
+                    case "AccessPointNotFoundException": return [3, 2];
+                    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException": return [3, 2];
+                    case "InvalidConfigurationRequestException": return [3, 4];
+                    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException": return [3, 4];
+                    case "ListenerNotFoundException": return [3, 6];
+                    case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException": return [3, 6];
+                    case "PolicyNotFoundException": return [3, 8];
+                    case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException": return [3, 8];
                 }
-                return [3 /*break*/, 10];
+                return [3, 10];
             case 2:
                 _c = [{}];
-                return [4 /*yield*/, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryAccessPointNotFoundExceptionResponse(parsedOutput, context)];
             case 3:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 4:
                 _d = [{}];
-                return [4 /*yield*/, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryInvalidConfigurationRequestExceptionResponse(parsedOutput, context)];
             case 5:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _d.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 6:
                 _e = [{}];
-                return [4 /*yield*/, deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryListenerNotFoundExceptionResponse(parsedOutput, context)];
             case 7:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 8:
                 _f = [{}];
-                return [4 /*yield*/, deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)];
+                return [4, deserializeAws_queryPolicyNotFoundExceptionResponse(parsedOutput, context)];
             case 9:
                 response = __assign.apply(void 0, [__assign.apply(void 0, _f.concat([(_h.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 10:
                 parsedBody = parsedOutput.body;
                 errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
@@ -2305,7 +2305,7 @@ var deserializeAws_querySetLoadBalancerPoliciesOfListenerCommandError = function
                 message = response.message || response.Message || errorCode;
                 response.message = message;
                 delete response.Message;
-                return [2 /*return*/, Promise.reject(Object.assign(new Error(message), response))];
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
         }
     });
 }); };
@@ -2315,7 +2315,7 @@ var deserializeAws_queryAccessPointNotFoundExceptionResponse = function (parsedO
         body = parsedOutput.body;
         deserialized = deserializeAws_queryAccessPointNotFoundException(body.Error, context);
         contents = __assign({ name: "AccessPointNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryCertificateNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2324,7 +2324,7 @@ var deserializeAws_queryCertificateNotFoundExceptionResponse = function (parsedO
         body = parsedOutput.body;
         deserialized = deserializeAws_queryCertificateNotFoundException(body.Error, context);
         contents = __assign({ name: "CertificateNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryDependencyThrottleExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2333,7 +2333,7 @@ var deserializeAws_queryDependencyThrottleExceptionResponse = function (parsedOu
         body = parsedOutput.body;
         deserialized = deserializeAws_queryDependencyThrottleException(body.Error, context);
         contents = __assign({ name: "DependencyThrottleException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryDuplicateAccessPointNameExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2342,7 +2342,7 @@ var deserializeAws_queryDuplicateAccessPointNameExceptionResponse = function (pa
         body = parsedOutput.body;
         deserialized = deserializeAws_queryDuplicateAccessPointNameException(body.Error, context);
         contents = __assign({ name: "DuplicateAccessPointNameException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryDuplicateListenerExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2351,7 +2351,7 @@ var deserializeAws_queryDuplicateListenerExceptionResponse = function (parsedOut
         body = parsedOutput.body;
         deserialized = deserializeAws_queryDuplicateListenerException(body.Error, context);
         contents = __assign({ name: "DuplicateListenerException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryDuplicatePolicyNameExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2360,7 +2360,7 @@ var deserializeAws_queryDuplicatePolicyNameExceptionResponse = function (parsedO
         body = parsedOutput.body;
         deserialized = deserializeAws_queryDuplicatePolicyNameException(body.Error, context);
         contents = __assign({ name: "DuplicatePolicyNameException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryDuplicateTagKeysExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2369,7 +2369,7 @@ var deserializeAws_queryDuplicateTagKeysExceptionResponse = function (parsedOutp
         body = parsedOutput.body;
         deserialized = deserializeAws_queryDuplicateTagKeysException(body.Error, context);
         contents = __assign({ name: "DuplicateTagKeysException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryInvalidConfigurationRequestExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2378,7 +2378,7 @@ var deserializeAws_queryInvalidConfigurationRequestExceptionResponse = function
         body = parsedOutput.body;
         deserialized = deserializeAws_queryInvalidConfigurationRequestException(body.Error, context);
         contents = __assign({ name: "InvalidConfigurationRequestException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryInvalidEndPointExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2387,7 +2387,7 @@ var deserializeAws_queryInvalidEndPointExceptionResponse = function (parsedOutpu
         body = parsedOutput.body;
         deserialized = deserializeAws_queryInvalidEndPointException(body.Error, context);
         contents = __assign({ name: "InvalidEndPointException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryInvalidSchemeExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2396,7 +2396,7 @@ var deserializeAws_queryInvalidSchemeExceptionResponse = function (parsedOutput,
         body = parsedOutput.body;
         deserialized = deserializeAws_queryInvalidSchemeException(body.Error, context);
         contents = __assign({ name: "InvalidSchemeException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryInvalidSecurityGroupExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2405,7 +2405,7 @@ var deserializeAws_queryInvalidSecurityGroupExceptionResponse = function (parsed
         body = parsedOutput.body;
         deserialized = deserializeAws_queryInvalidSecurityGroupException(body.Error, context);
         contents = __assign({ name: "InvalidSecurityGroupException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryInvalidSubnetExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2414,7 +2414,7 @@ var deserializeAws_queryInvalidSubnetExceptionResponse = function (parsedOutput,
         body = parsedOutput.body;
         deserialized = deserializeAws_queryInvalidSubnetException(body.Error, context);
         contents = __assign({ name: "InvalidSubnetException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryListenerNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2423,7 +2423,7 @@ var deserializeAws_queryListenerNotFoundExceptionResponse = function (parsedOutp
         body = parsedOutput.body;
         deserialized = deserializeAws_queryListenerNotFoundException(body.Error, context);
         contents = __assign({ name: "ListenerNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2432,7 +2432,7 @@ var deserializeAws_queryLoadBalancerAttributeNotFoundExceptionResponse = functio
         body = parsedOutput.body;
         deserialized = deserializeAws_queryLoadBalancerAttributeNotFoundException(body.Error, context);
         contents = __assign({ name: "LoadBalancerAttributeNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryOperationNotPermittedExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2441,7 +2441,7 @@ var deserializeAws_queryOperationNotPermittedExceptionResponse = function (parse
         body = parsedOutput.body;
         deserialized = deserializeAws_queryOperationNotPermittedException(body.Error, context);
         contents = __assign({ name: "OperationNotPermittedException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryPolicyNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2450,7 +2450,7 @@ var deserializeAws_queryPolicyNotFoundExceptionResponse = function (parsedOutput
         body = parsedOutput.body;
         deserialized = deserializeAws_queryPolicyNotFoundException(body.Error, context);
         contents = __assign({ name: "PolicyNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryPolicyTypeNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2459,7 +2459,7 @@ var deserializeAws_queryPolicyTypeNotFoundExceptionResponse = function (parsedOu
         body = parsedOutput.body;
         deserialized = deserializeAws_queryPolicyTypeNotFoundException(body.Error, context);
         contents = __assign({ name: "PolicyTypeNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_querySubnetNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2468,7 +2468,7 @@ var deserializeAws_querySubnetNotFoundExceptionResponse = function (parsedOutput
         body = parsedOutput.body;
         deserialized = deserializeAws_querySubnetNotFoundException(body.Error, context);
         contents = __assign({ name: "SubnetNotFoundException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryTooManyAccessPointsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2477,7 +2477,7 @@ var deserializeAws_queryTooManyAccessPointsExceptionResponse = function (parsedO
         body = parsedOutput.body;
         deserialized = deserializeAws_queryTooManyAccessPointsException(body.Error, context);
         contents = __assign({ name: "TooManyAccessPointsException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryTooManyPoliciesExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2486,7 +2486,7 @@ var deserializeAws_queryTooManyPoliciesExceptionResponse = function (parsedOutpu
         body = parsedOutput.body;
         deserialized = deserializeAws_queryTooManyPoliciesException(body.Error, context);
         contents = __assign({ name: "TooManyPoliciesException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryTooManyTagsExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2495,7 +2495,7 @@ var deserializeAws_queryTooManyTagsExceptionResponse = function (parsedOutput, c
         body = parsedOutput.body;
         deserialized = deserializeAws_queryTooManyTagsException(body.Error, context);
         contents = __assign({ name: "TooManyTagsException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var deserializeAws_queryUnsupportedProtocolExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
@@ -2504,7 +2504,7 @@ var deserializeAws_queryUnsupportedProtocolExceptionResponse = function (parsedO
         body = parsedOutput.body;
         deserialized = deserializeAws_queryUnsupportedProtocolException(body.Error, context);
         contents = __assign({ name: "UnsupportedProtocolException", $fault: "client", $metadata: deserializeMetadata(parsedOutput) }, deserialized);
-        return [2 /*return*/, contents];
+        return [2, contents];
     });
 }); };
 var serializeAws_queryAccessLog = function (input, context) {
@@ -4607,7 +4607,6 @@ var deserializeMetadata = function (output) {
         cfId: output.headers["x-amz-cf-id"],
     });
 };
-// Collect low-level response body stream to Uint8Array.
 var collectBody = function (streamBody, context) {
     if (streamBody === void 0) { streamBody = new Uint8Array(); }
     if (streamBody instanceof Uint8Array) {
@@ -4615,7 +4614,6 @@ var collectBody = function (streamBody, context) {
     }
     return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
 };
-// Encode Uint8Array data into string with utf-8.
 var collectBodyString = function (streamBody, context) {
     return collectBody(streamBody, context).then(function (body) { return context.utf8Encoder(body); });
 };
@@ -4623,7 +4621,7 @@ var buildHttpRpcRequest = function (context, headers, path, resolvedHostname, bo
     var _a, hostname, _b, protocol, port, basePath, contents;
     return __generator(this, function (_c) {
         switch (_c.label) {
-            case 0: return [4 /*yield*/, context.endpoint()];
+            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 = {
@@ -4640,7 +4638,7 @@ var buildHttpRpcRequest = function (context, headers, path, resolvedHostname, bo
                 if (body !== undefined) {
                     contents.body = body;
                 }
-                return [2 /*return*/, new __HttpRequest(contents)];
+                return [2, new __HttpRequest(contents)];
         }
     });
 }); };